@idlebox/common 1.3.4 → 1.3.7

package/src/function/asyncCallbackList.ts

@@ -1,75 +0,0 @@
-import { nameFunction } from './functionName';
-
-export interface MyAsyncCallback<Argument extends unknown[]> {
-	displayName?: string;
-
-	(...param: Argument): Promise<void | undefined | boolean> | void | undefined | boolean;
-}
-
-/**
- * like CallbackList, but async
- */
-export class AsyncCallbackList<Argument extends unknown[]> {
-	protected list: MyAsyncCallback<Argument>[] = [];
-	protected running: boolean = false;
-
-	constructor() {
-		this.run = (this.run as any).bind(this);
-	}
-
-	count() {
-		return this.list.length;
-	}
-
-	reset() {
-		if (this.running) {
-			throw new Error("Can not reset when it's running.");
-		}
-		this.list.length = 0;
-	}
-
-	/**
-	 * @param name optional name of `item` (will assign displayName to `item`)
-	 * @returns function list length
-	 */
-	add(item: MyAsyncCallback<Argument>, name?: string): number {
-		if (this.running) {
-			throw new Error("Can not add callback when it's running.");
-		}
-		if (name) {
-			nameFunction(name, item);
-		}
-		return this.list.push(item);
-	}
-
-	/**
-	 * @returns if removed: return `item`; if did not exists: return null
-	 */
-	remove(item: MyAsyncCallback<Argument>): null | MyAsyncCallback<Argument> {
-		if (this.running) {
-			throw new Error("Can not remove callback when it's running.");
-		}
-		const found = this.list.indexOf(item);
-		if (found !== -1) {
-			return this.list.splice(found, 1)[0];
-		}
-		return null;
-	}
-
-	/**
-	 * Stop run if one callback return `true`
-	 * @returns {boolean} true if one callback return true
-	 */
-	async run(...argument: Argument): Promise<boolean> {
-		this.running = true;
-		let ret: boolean | undefined | void;
-		for (const cb of this.list) {
-			ret = await cb(...argument);
-			if (ret === true) {
-				break;
-			}
-		}
-		this.running = false;
-		return ret || false;
-	}
-}

package/src/function/callbackList.ts

@@ -1,84 +0,0 @@
-import { nameFunction } from './functionName';
-
-export interface MyCallback<Argument extends unknown[]> {
-	displayName?: string;
-
-	(...param: Argument): any;
-}
-
-/**
- * Manage a list of callback
- */
-export class CallbackList<Argument extends unknown[]> {
-	protected list: MyCallback<Argument>[] = [];
-	protected running: boolean = false;
-	protected stop: boolean = false;
-
-	constructor() {
-		this.run = (this.run as any).bind(this);
-	}
-
-	count() {
-		return this.list.length;
-	}
-
-	reset() {
-		if (this.running) {
-			throw new Error("Can not reset when it's running.");
-		}
-		this.list.length = 0;
-	}
-
-	/**
-	 * @param name optional name of `item` (will assign displayName to `item`)
-	 * @returns function list length
-	 */
-	add(item: MyCallback<Argument>, name?: string): number {
-		if (this.running) {
-			throw new Error("Can not add callback when it's running.");
-		}
-		if (name) {
-			nameFunction(name, item);
-		}
-		return this.list.push(item);
-	}
-
-	/**
-	 * @returns if removed: return `item`; if did not exists: return null
-	 */
-	remove(item: MyCallback<Argument>): null | MyCallback<Argument> {
-		if (this.running) {
-			throw new Error("Can not remove callback when it's running.");
-		}
-		const found = this.list.indexOf(item);
-		if (found !== -1) {
-			return this.list.splice(found, 1)[0];
-		}
-		return null;
-	}
-
-	/**
-	 * @returns {boolean} true if every callback called, false if stop in middle
-	 */
-	run(...argument: Argument): boolean {
-		if (this.running) {
-			throw new Error("can not run CallbackList in it's callback.");
-		}
-		this.stop = false;
-
-		this.running = true;
-		for (const cb of this.list) {
-			if (this.stop) break;
-			cb(...argument);
-		}
-		this.running = false;
-
-		const ret = !this.stop;
-		this.stop = false;
-		return ret;
-	}
-
-	stopRun() {
-		this.stop = true;
-	}
-}

package/src/function/delayCallbackList.ts

@@ -1,45 +0,0 @@
-import { nameFunction } from './functionName';
-
-export interface MyDelayCallback<Argument extends unknown[]> {
-	displayName?: string;
-
-	(...param: Argument): void;
-}
-
-/**
- * remember arguments after run
- * run all later added function with memorized argument
- */
-export class DelayCallbackList<Argument extends unknown[]> {
-	private delayArgument?: Argument;
-	private delayComplete: boolean = false;
-
-	protected list?: MyDelayCallback<Argument>[] = [];
-
-	count() {
-		return this.list?.length ?? 0;
-	}
-
-	add(item: MyDelayCallback<Argument>, name?: string) {
-		if (name) {
-			nameFunction(name, item);
-		}
-		if (this.delayComplete) {
-			item(...this.delayArgument!);
-		} else {
-			this.list!.push(item);
-		}
-	}
-
-	run(argument: Argument) {
-		if (this.delayComplete) {
-			throw new Error('call to delay callback twice!');
-		}
-		this.delayComplete = true;
-		this.delayArgument = argument;
-		this.list!.forEach((cb) => {
-			cb(...argument);
-		});
-		delete this.list;
-	}
-}

package/src/function/functionName.ts

@@ -1,39 +0,0 @@
-/**
- * Function with displayName
- */
-export interface NamedFunction extends Function {
-	displayName: string;
-}
-
-/**
- * Get displayName/name of a function
- */
-export function functionName(func: Function) {
-	return (func as NamedFunction).displayName || func.name;
-}
-
-/**
- * Set displayName of a function
- */
-export function nameFunction<T extends Function>(name: string, func: T): T & NamedFunction {
-	return Object.assign(func, {
-		displayName: name,
-		inspect() {
-			return `[Function: ${name}]`;
-		},
-	});
-}
-
-export interface MaybeNamedFunction extends Function {
-	displayName?: string;
-}
-
-/**
- * Assert function must have oneof displayName/name property
- */
-export function assertFunctionHasName(func: MaybeNamedFunction) {
-	if (!func.displayName && !func.name) {
-		console.error(func);
-		throw new TypeError('function must have name!');
-	}
-}

package/src/lifecycle/dispose/bridges/rxjs.ts

@@ -1,6 +0,0 @@
-interface Unsubscribable {
-	unsubscribe(): void;
-}
-export function unsubscribableToDisposable(subscription: Unsubscribable) {
-	return { dispose: () => subscription.unsubscribe() };
-}

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;
-}