@idlebox/common 1.3.6 → 1.3.7

package/src/lifecycle/dispose/disposableEvent.ts

@@ -1,117 +0,0 @@
-import { IDisposable } from './lifecycle';
-
-declare const AbortController: new () => any;
-
-export interface IEventListenerOptions {
-	capture?: boolean;
-	once?: boolean;
-	passive?: boolean;
-}
-
-export interface IEventHostObject<T extends Function> {
-	addEventListener(type: string, handler: T, options?: IEventListenerOptions): any;
-	removeEventListener(type: string, handler: T, options?: IEventListenerOptions): any;
-}
-
-export interface IEventEmitterObject<T extends Function> {
-	addListener(type: string, handler: T): any;
-	removeListener(type: string, handler: T): any;
-}
-
-export function addDisposableEventListener<T extends Function>(
-	target: IEventHostObject<T> | IEventEmitterObject<T>,
-	type: string,
-	options: IEventListenerOptions,
-	handler: T
-): IDisposable;
-
-export function addDisposableEventListener<T extends Function>(
-	target: IEventHostObject<T> | IEventEmitterObject<T>,
-	type: string,
-	handler: T
-): IDisposable;
-
-export function addDisposableEventListener<T extends Function>(
-	target: IEventHostObject<T> | IEventEmitterObject<T>,
-	type: string,
-	_options: IEventListenerOptions | T | undefined,
-	_handler?: T
-): IDisposable {
-	if (!_handler) {
-		if (typeof _options === 'function') {
-			_handler = _options;
-			_options = undefined;
-		} else {
-			throw new Error('missing handler');
-		}
-	}
-
-	const handler = _handler as T;
-	const options = _options as IEventListenerOptions;
-
-	let remove: IDisposable['dispose'];
-
-	if ('addEventListener' in target) {
-		if (passiveSupported === undefined || abortSupported === undefined) {
-			checkAllSupport(target);
-		}
-		const [abort, xOptions] = check(options);
-		target.addEventListener(type, handler, xOptions);
-		if (abort) {
-			remove = () => {
-				abort;
-			};
-		} else {
-			remove = () => {
-				target.removeEventListener(type, handler, xOptions);
-			};
-		}
-	} else {
-		target.addListener(type, handler);
-		remove = () => {
-			target.removeListener(type, handler);
-		};
-	}
-	return { dispose: remove };
-}
-
-let passiveSupported: boolean;
-let abortSupported: boolean;
-function check(options: IEventListenerOptions = {}): [{ abort(): void } | undefined, IEventListenerOptions] {
-	if (!passiveSupported) {
-		return [undefined, (options.capture || false) as any];
-	}
-
-	if (abortSupported) {
-		const controller = new AbortController();
-		(options as any).signal = controller.signal;
-		return [controller, options];
-	} else {
-		return [undefined, options];
-	}
-}
-
-function checkAllSupport(ele: IEventHostObject<any>) {
-	passiveSupported = checkSupport('passive', ele);
-	abortSupported = typeof AbortController !== 'undefined' && checkSupport('signal', ele);
-}
-
-function checkSupport(field: string, ele: IEventHostObject<any>) {
-	let supported = false;
-	try {
-		const options = {
-			get [field]() {
-				// This function will be called when the browser
-				//   attempts to access the passive property.
-				supported = true;
-				return undefined;
-			},
-		};
-
-		ele.addEventListener('_test_', null, options);
-		ele.removeEventListener('_test_', null, options);
-	} catch (err) {
-		supported = false;
-	}
-	return supported;
-}

package/src/lifecycle/dispose/disposedError.ts

@@ -1,16 +0,0 @@
-import { getErrorFrame } from '../../error/getFrame';
-import { tryInspect } from '../../debugging/tryInspect';
-
-/**
- * Error when call dispose() twice
- */
-export class DisposedError extends Error {
-	constructor(object: any, previous: Error) {
-		super(`Object [${tryInspect(object)}] has already disposed at ${getErrorFrame(previous, 2)}.`);
-		this.name = 'Warning';
-	}
-}
-
-export function isDisposedError(error: any): boolean {
-	return error instanceof DisposedError;
-}

package/src/lifecycle/dispose/lifecycle.async.ts

@@ -1,61 +0,0 @@
-import { convertCatchedError } from '../../error/convertUnknown';
-import { Emitter, EventRegister } from '../event/event';
-import { DisposedError } from './disposedError';
-import { IAsyncDisposable, IDisposableBaseInternal } from './lifecycle';
-
-/**
- * Async version of Disposable
- * @public
- */
-export class AsyncDisposable implements IAsyncDisposable, IDisposableBaseInternal {
-	private readonly _disposables: IAsyncDisposable[] = [];
-
-	protected readonly _onDisposeError = new Emitter<Error>();
-	public readonly onDisposeError: EventRegister<Error> = this._onDisposeError.register;
-
-	protected readonly _onBeforeDispose = new Emitter<void>();
-	public readonly onBeforeDispose: EventRegister<void> = this._onBeforeDispose.register;
-
-	private _disposed?: Error;
-
-	public get hasDisposed() {
-		return !!this._disposed;
-	}
-
-	/**
-	 * @throws if already disposed
-	 */
-	public assertNotDisposed() {
-		if (this._disposed) {
-			throw new DisposedError(this, this._disposed);
-		}
-	}
-
-	/**
-	 * register a disposable object
-	 */
-	public _register<T extends IAsyncDisposable>(d: T): T {
-		this.assertNotDisposed();
-		this._disposables.unshift(d);
-		return d;
-	}
-
-	public async dispose(): Promise<void> {
-		if (this._disposed) {
-			console.warn(new DisposedError(this, this._disposed).message);
-			return;
-		}
-		this._onBeforeDispose.fireNoError();
-		this._disposed = new Error('disposed');
-
-		this._disposables.push(this._onBeforeDispose);
-		this._disposables.push(this._onDisposeError);
-		for (const cb of this._disposables) {
-			try {
-				await cb.dispose();
-			} catch (e) {
-				this._onDisposeError.fire(convertCatchedError(e));
-			}
-		}
-	}
-}

package/src/lifecycle/dispose/lifecycle.global.ts

@@ -1,61 +0,0 @@
-import { globalSingletonStrong } from '../../platform/globalSingleton';
-import { createSymbol } from '../../platform/globalSymbol';
-import { IDisposable } from './lifecycle';
-import { AsyncDisposable } from './lifecycle.async';
-
-const symbol = createSymbol('lifecycle', 'application');
-
-function create() {
-	return new AsyncDisposable();
-}
-
-/**
- * Add object into global disposable store, it will be dispose when call to `disposeGlobal`
- */
-export function registerGlobalLifecycle(object: IDisposable) {
-	globalSingletonStrong(symbol, create)._register(object);
-}
-
-/**
- * Same as disposeGlobal, but do not throw by duplicate call
- */
-export function ensureDisposeGlobal() {
-	const obj = globalSingletonStrong<AsyncDisposable>(symbol);
-	if (obj && !obj.hasDisposed) {
-		return Promise.resolve(obj.dispose());
-	} else {
-		return Promise.resolve();
-	}
-}
-
-/**
- * Dispose the global disposable store
- * this function must be manually called by user, when registerGlobalLifecycle is used
- *
- * @throws when call twice
- */
-export function disposeGlobal() {
-	const obj = globalSingletonStrong<AsyncDisposable>(symbol);
-	if (obj && obj.hasDisposed) {
-		throw new Error('global already disposed.');
-	} else if (obj) {
-		return Promise.resolve(obj.dispose());
-	} else {
-		return Promise.resolve();
-	}
-}
-
-/**
- * Note: sub-class should singleton
- * @alpha
- */
-export abstract class LifecycleObject extends AsyncDisposable {
-	/** sub-class should shutdown program in this method */
-	protected abstract done(): void;
-
-	public async dispose(): Promise<void> {
-		return super.dispose().finally(() => {
-			this.done();
-		});
-	}
-}

package/src/lifecycle/dispose/lifecycle.sync.ts

@@ -1,79 +0,0 @@
-import { DisposedError } from './disposedError';
-import { Emitter, EventRegister } from '../event/event';
-import { IDisposable, IDisposableBaseInternal } from './lifecycle';
-
-export abstract class DisposableOnce implements IDisposable {
-	private _disposed?: Error;
-
-	public get hasDisposed() {
-		return !!this._disposed;
-	}
-	public dispose(): void {
-		if (this._disposed) {
-			console.warn(new DisposedError(this, this._disposed).message);
-			return;
-		}
-		this._disposed = new Error('disposed');
-		this._dispose();
-	}
-
-	protected abstract _dispose(): void;
-}
-
-/**
- * Standalone disposable class, can use as instance or base class.
- */
-export class Disposable implements IDisposable, IDisposableBaseInternal {
-	private readonly _disposables: IDisposable[] = [];
-
-	protected readonly _onDisposeError = new Emitter<Error>();
-	public readonly onDisposeError: EventRegister<Error> = this._onDisposeError.register;
-
-	protected readonly _onBeforeDispose = new Emitter<void>();
-	public readonly onBeforeDispose: EventRegister<void> = this._onBeforeDispose.register;
-
-	private _disposed?: Error;
-
-	public get hasDisposed() {
-		return !!this._disposed;
-	}
-
-	/**
-	 * @throws if already disposed
-	 */
-	public assertNotDisposed() {
-		if (this._disposed) {
-			throw new DisposedError(this, this._disposed);
-		}
-	}
-
-	public _register<T extends IDisposable>(d: T): T {
-		this.assertNotDisposed();
-		this._disposables.unshift(d);
-		return d;
-	}
-
-	public dispose(): void {
-		if (this._disposed) {
-			console.warn(new DisposedError(this, this._disposed).message);
-			return;
-		}
-		this._onBeforeDispose.fireNoError();
-		this._disposed = new Error('disposed');
-
-		this._disposables.push(this._onBeforeDispose);
-		this._disposables.push(this._onDisposeError);
-		for (const item of this._disposables.values()) {
-			try {
-				item.dispose();
-			} catch (e) {
-				if (e instanceof Error) {
-					this._onDisposeError.fire(e);
-				} else {
-					console.error('error during dispose, throw:', e);
-					this._onDisposeError.fire(new Error('' + e));
-				}
-			}
-		}
-	}
-}

package/src/lifecycle/dispose/lifecycle.ts

@@ -1,28 +0,0 @@
-import { EventRegister } from '../event/event';
-
-/**
- * @private
- */
-export interface IDisposableBaseInternal {
-	onDisposeError: EventRegister<Error>;
-	onBeforeDispose: EventRegister<void>;
-	readonly hasDisposed: boolean;
-}
-
-/** @public */
-export interface IDisposable {
-	dispose(): void;
-}
-
-/** @public */
-export interface IAsyncDisposable {
-	dispose(): void | Promise<void>;
-}
-
-/**
- * Convert "dispose function" to disposable object
- * @public
- */
-export function toDisposable(fn: () => void): IDisposable {
-	return { dispose: fn };
-}

package/src/lifecycle/event/event.ts

@@ -1,63 +0,0 @@
-import { IDisposable } from '../dispose/lifecycle';
-
-export interface EventHandler<T> {
-	(data: T): void;
-}
-
-export interface EventRegister<T> {
-	(callback: EventHandler<T>): IDisposable;
-}
-
-export class Emitter<T> implements IDisposable {
-	private readonly _callbacks: EventHandler<T>[] = [];
-
-	constructor() {
-		this.handle = this.handle.bind(this);
-	}
-
-	listenerCount() {
-		return this._callbacks.length;
-	}
-
-	fire(data: T) {
-		for (const callback of this._callbacks) {
-			callback(data);
-		}
-	}
-
-	/**
-	 * Same with `fire`, but do not stop run when catch error
-	 */
-	public fireNoError(data: T) {
-		for (const callback of this._callbacks) {
-			try {
-				callback(data);
-			} catch (e) {
-				console.error('Error ignored: ', e);
-			}
-		}
-	}
-
-	get register(): EventRegister<T> {
-		return this.handle;
-	}
-
-	handle(callback: EventHandler<T>): IDisposable {
-		this._callbacks.unshift(callback);
-		return {
-			dispose: () => {
-				const index = this._callbacks.indexOf(callback);
-				if (index !== -1) {
-					this._callbacks.splice(index, 1);
-				}
-			},
-		};
-	}
-
-	dispose() {
-		this._callbacks.length = 0;
-		this.fire = this.handle = () => {
-			throw new Error('Event is disposed');
-		};
-	}
-}

package/src/lifecycle/promise/cancel.ts

@@ -1,16 +0,0 @@
-const canceledName = 'Canceled';
-
-/**
- * Error when cancel() is called
- * @public
- */
-export class CanceledError extends Error {
-	constructor() {
-		super(canceledName);
-	}
-}
-
-/** @public */
-export function isCanceledError(error: any): boolean {
-	return error instanceof CanceledError;
-}

package/src/lifecycle/promise/cancellationToken/driver.browser.ts

@@ -1,55 +0,0 @@
-import { EventHandler } from '../../event/event';
-
-import type { CancellationDriver, __CancellationToken } from './source';
-
-declare const AbortController: any; // TODO
-declare type AbortController = any; // TODO
-
-/** @internal */
-export class CancellationDriverBrowser implements CancellationDriver {
-	private readonly controller: AbortController;
-	public readonly token: __CancellationToken;
-	private readonly disposeList: (() => void)[] = [];
-
-	constructor() {
-		this.controller = new AbortController();
-
-		const signal = this.controller.signal;
-		signal.addEventListener('abort', () => {
-			token.isCancellationRequested = true;
-		});
-
-		const disposeList = this.disposeList;
-		const token = {
-			isCancellationRequested: false,
-			onCancellationRequested(listener: EventHandler<void>) {
-				const callback = () => listener();
-
-				signal.addEventListener('abort', callback);
-
-				const dispose = () => signal.removeEventListener('abort', callback);
-				disposeList.push(dispose);
-
-				return { dispose };
-			},
-		};
-
-		this.token = token;
-	}
-
-	cancel() {
-		if (this.token.isCancellationRequested) {
-			console.warn('[CancellationTokenSource] is already canceled.');
-		} else {
-			this.token.isCancellationRequested = true;
-			this.controller.abort();
-		}
-	}
-
-	dispose() {
-		for (const removeListener of this.disposeList) removeListener();
-		if (!this.token.isCancellationRequested) {
-			this.controller.abort();
-		}
-	}
-}

package/src/lifecycle/promise/cancellationToken/driver.common.ts

@@ -1,43 +0,0 @@
-import { IDisposable } from '../../dispose/lifecycle';
-import { Emitter, EventHandler } from '../../event/event';
-
-import type { CancellationDriver, __CancellationToken } from './source';
-
-/** @internal */
-export class CancellationDriverCommon implements CancellationDriver {
-	private readonly emitter: Emitter<void>;
-	public readonly token: __CancellationToken;
-	private readonly disposeList: IDisposable[] = [];
-
-	constructor() {
-		const emitter = new Emitter<void>();
-		this.emitter = emitter;
-
-		const disposeList = this.disposeList;
-		const token = {
-			isCancellationRequested: false,
-			onCancellationRequested(callback: EventHandler<void>) {
-				const ret = emitter.handle(callback);
-				disposeList.push(ret);
-				return ret;
-			},
-		};
-		this.token = token;
-	}
-
-	cancel() {
-		if (this.token.isCancellationRequested) {
-			console.warn('[CancellationTokenSource] is already canceled.');
-		} else {
-			this.token.isCancellationRequested = true;
-			this.emitter.fire();
-		}
-	}
-
-	dispose() {
-		for (const listen of this.disposeList) listen.dispose();
-		if (!this.token.isCancellationRequested) {
-			this.cancel();
-		}
-	}
-}

package/src/lifecycle/promise/cancellationToken/source.ts

@@ -1,48 +0,0 @@
-import { globalObject } from '../../../platform/globalObject';
-import { IDisposable } from '../../dispose/lifecycle';
-import { DisposableOnce } from '../../dispose/lifecycle.sync';
-import { EventHandler } from '../../event/event';
-import { CancellationDriverBrowser } from './driver.browser';
-import { CancellationDriverCommon } from './driver.common';
-
-/** @public */
-export interface CancellationToken {
-	readonly isCancellationRequested: boolean;
-	onCancellationRequested(callback: EventHandler<void>): IDisposable;
-}
-
-/** @internal */
-export interface __CancellationToken {
-	isCancellationRequested: boolean;
-	onCancellationRequested(callback: EventHandler<void>): IDisposable;
-}
-
-/** @internal */
-export interface CancellationDriver extends IDisposable {
-	readonly token: CancellationToken;
-	cancel(): void;
-}
-
-/** @public */
-export class CancellationTokenSource extends DisposableOnce implements IDisposable {
-	private readonly driver: CancellationDriver;
-	public readonly token: CancellationToken;
-
-	constructor() {
-		super();
-		if ('AbortController' in globalObject) {
-			this.driver = new CancellationDriverBrowser();
-		} else {
-			this.driver = new CancellationDriverCommon();
-		}
-		this.token = this.driver.token;
-	}
-
-	cancel(): void {
-		this.driver.cancel();
-	}
-
-	_dispose(): void {
-		this.driver.dispose();
-	}
-}

package/src/lifecycle/promise/deferredPromise.ts

@@ -1,102 +0,0 @@
-import { CanceledError } from './cancel';
-
-export type ValueCallback<T = any> = (value: T | Promise<T>) => void;
-export type ProgressCallback<T = any> = (value: T) => void;
-
-export interface IProgressHolder<T, PT> {
-	progress(fn: ProgressCallback<PT>): Promise<T> & IProgressHolder<T, PT>;
-}
-
-/**
- * a promise can resolve or reject later
- * @public
- */
-export class DeferredPromise<T, PT = any> {
-	public readonly p: Promise<T> & IProgressHolder<T, PT>;
-	private declare _completeCallback: ValueCallback<T>;
-	private declare _errorCallback: (err: any) => void;
-	private _state: boolean | null = null;
-	private _progressList?: ProgressCallback<PT>[] = [];
-
-	constructor() {
-		this.p = Object.assign(
-			new Promise<any>((c, e) => {
-				this._completeCallback = c;
-				this._errorCallback = e;
-			}),
-			{
-				progress: (fn: ProgressCallback<PT>) => {
-					this.progress(fn);
-					return this.p;
-				},
-			}
-		);
-		this.p.finally(() => {
-			delete this._progressList;
-		});
-	}
-
-	notify(progress: PT): this {
-		for (const cb of this._progressList!) {
-			cb(progress);
-		}
-		return this;
-	}
-
-	progress(fn: ProgressCallback<PT>): void {
-		this._progressList!.push(fn);
-	}
-
-	get completed(): boolean {
-		return typeof this._state === 'boolean';
-	}
-
-	get resolved(): boolean {
-		return this._state === true;
-	}
-
-	get rejected(): boolean {
-		return this._state === false;
-	}
-
-	/**
-	 * resolve the promise
-	 */
-	public complete(value: T) {
-		this._state = true;
-		this._completeCallback(value);
-	}
-
-	/**
-	 * reject the promise
-	 */
-	public error(err: any) {
-		this._state = false;
-		this._errorCallback(err);
-	}
-
-	/**
-	 * reject the promise with CancelError
-	 */
-	public cancel() {
-		this._state = false;
-		this._errorCallback(new CanceledError());
-	}
-
-	/**
-	 * Convert promise into deferred
-	 * returns a DeferredPromise, resolve when prev resolve, reject when prev reject
-	 */
-	static wrap(prev: Promise<any>) {
-		const p = new DeferredPromise();
-		prev.then(
-			(d) => {
-				p.complete(d);
-			},
-			(e) => {
-				p.error(e);
-			}
-		);
-		return p;
-	}
-}