@idlebox/common 1.3.15 → 1.3.16

package/src/lifecycle/event/event.ts

@@ -0,0 +1,81 @@
+import { IDisposable } from '../dispose/lifecycle';
+
+export interface EventHandler<T> {
+	(data: T): void;
+}
+
+export interface EventRegister<T> {
+	(callback: EventHandler<T>): IDisposable;
+}
+
+/**
+ * 事件注册对象
+ * @public
+ */
+export class Emitter<T> implements IDisposable {
+	private readonly _callbacks: EventHandler<T>[] = [];
+
+	constructor() {
+		this.handle = this.handle.bind(this);
+	}
+
+	/**
+	 * @returns 当前注册回调数量
+	 */
+	public listenerCount() {
+		return this._callbacks.length;
+	}
+
+	/**
+	 * 触发本事件
+	 * @param data 回调数据
+	 */
+	public fire(data: T) {
+		for (const callback of this._callbacks) {
+			callback(data);
+		}
+	}
+
+	/**
+	 * 与 `fire()`相同，但是忽略任何错误，并且即便出错也继续执行全部callback
+	 */
+	public fireNoError(data: T) {
+		for (const callback of this._callbacks) {
+			try {
+				callback(data);
+			} catch (e) {
+				console.error('Error ignored: ', e);
+			}
+		}
+	}
+
+	/**
+	 * 获取handle()方法的引用
+	 */
+	get register(): EventRegister<T> {
+		return this.handle;
+	}
+
+	/**
+	 * 注册本事件的新回调
+	 * @param callback 回调函数
+	 */
+	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/event/memorized.ts

@@ -0,0 +1,39 @@
+import { IDisposable } from '../dispose/lifecycle';
+import { Emitter, EventHandler } from './event';
+
+/**
+ * 会记住上次fire的内容，并在每个新的handler注册时立即调用一次的Emitter
+ * 显然，这会对fire的内容保留一个引用，可以调用forget()取消
+ * @public
+ */
+export class MemorizedEmitter<T> extends Emitter<T> {
+	private _memo?: T;
+	private _is_memo: boolean = false;
+
+	public override fire(data: T) {
+		this._memo = data;
+		this._is_memo = true;
+		return super.fire(data);
+	}
+
+	public override fireNoError(data: T) {
+		this._memo = data;
+		this._is_memo = true;
+		return super.fireNoError(data);
+	}
+
+	public override handle(callback: EventHandler<T>): IDisposable {
+		if (this._is_memo) callback(this._memo!);
+		return super.handle(callback);
+	}
+
+	public forget() {
+		delete this._memo;
+		this._is_memo = false;
+	}
+
+	dispose(): void {
+		this.forget();
+		super.dispose();
+	}
+}

package/src/lifecycle/promise/cancel.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,104 @@
+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;
+			})
+			.catch(() => void 0);
+	}
+
+	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;
+	}
+}

package/src/lifecycle/timeout/timeout.ts

@@ -0,0 +1,48 @@
+import { TimeoutError } from './timeoutError';
+import { DeferredPromise } from '../promise/deferredPromise';
+
+/**
+ * @returns promise reject with TimeoutError after specific time
+ */
+export function timeout(ms: number, error = 'no response'): Promise<never> {
+	return new Promise((_, reject) => {
+		setTimeout(() => {
+			reject(new TimeoutError(ms, error));
+		}, ms);
+	});
+}
+
+/**
+ * @returns promise resolve after specific time
+ */
+export function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => {
+		setTimeout(() => {
+			resolve();
+		}, ms);
+	});
+}
+
+export function timeoutPromise<T>(ms: number, p: Promise<T>): Promise<T>;
+export function timeoutPromise<T>(ms: number, message: string, p: Promise<T>): Promise<T>;
+export function timeoutPromise<T, PT = any>(ms: number, p: DeferredPromise<T, PT>): DeferredPromise<T, PT>;
+export function timeoutPromise<T, PT = any>(
+	ms: number,
+	message: string,
+	p: DeferredPromise<T, PT>
+): DeferredPromise<T, PT>;
+
+export function timeoutPromise<T>(ms: number, message: string | T, p?: T): T {
+	let msg: string | undefined;
+	if (typeof message !== 'string') {
+		p = message;
+		msg = undefined;
+	} else {
+		msg = message;
+	}
+	if (p instanceof DeferredPromise) {
+		return Promise.race([p.p, timeout(ms, msg)]).then(() => p) as any;
+	} else {
+		return Promise.race([p, timeout(ms, msg)]).then(() => p) as any;
+	}
+}

package/src/lifecycle/timeout/timeoutError.ts

@@ -0,0 +1,16 @@
+import { humanDate } from '../../date/timeString';
+
+/**
+ * Error when timeout() done
+ * @public
+ */
+export class TimeoutError extends Error {
+	constructor(time: number, what: string = 'no response') {
+		super(`Timeout: ${what} in ${humanDate.deltaTiny(time)}`);
+	}
+}
+
+/** @public */
+export function isTimeoutError(error: Error): error is TimeoutError {
+	return error instanceof TimeoutError;
+}

package/src/log/logger.ts

@@ -0,0 +1,148 @@
+import { nameFunction } from '../function/functionName';
+import { isWeb } from '../platform/os';
+
+export enum ColorKind {
+	DISABLE,
+	TERMINAL,
+	WEB,
+	DETECT,
+}
+
+export interface WrappedConsoleOptions {
+	parent?: Console;
+	bind?: boolean;
+}
+
+export abstract class WrappedConsole {
+	public declare info: Console['info'];
+	public declare log: Console['log'];
+	public declare success: Console['log'];
+	public declare debug: Console['debug'];
+	public declare error: Console['error'];
+	public declare trace: Console['trace'];
+	public declare warn: Console['warn'];
+	public declare assert: Console['assert'];
+
+	public declare time: Console['time'];
+	public declare timeEnd: Console['timeEnd'];
+	public declare timeLog: Console['timeLog'];
+	public declare count: Console['count'];
+	public declare countReset: Console['countReset'];
+	public declare group: Console['group'];
+	public declare groupCollapsed: Console['groupCollapsed'];
+	public declare groupEnd: Console['groupEnd'];
+
+	public declare table: Console['table'];
+	public declare dir: Console['dir'];
+	public declare clear: Console['clear'];
+
+	protected readonly title: string;
+	protected readonly parent: Console;
+	protected readonly bind: boolean;
+
+	constructor(title: string, { parent, bind }: WrappedConsoleOptions = {}) {
+		this.title = title;
+		this.parent = parent || console;
+		this.bind = bind || false;
+
+		this.info = this.wrapMessageAt('info', 0);
+		this.log = this.wrapMessageAt('log', 0);
+		this.success = this.wrapMessageAt('log', 0);
+		this.debug = this.wrapMessageAt('debug', 0);
+		this.error = this.wrapMessageAt('error', 0);
+		this.trace = this.wrapMessageAt('trace', 0);
+		this.warn = this.wrapMessageAt('warn', 0);
+		this.assert = this.wrapMessageAt('assert', 1);
+
+		this.time = this.wrapMessageAt('time', 0);
+		this.timeEnd = this.wrapMessageAt('timeEnd', 0);
+		this.timeLog = this.wrapMessageAt('timeLog', 0);
+		this.count = this.wrapMessageAt('count', 0);
+		this.countReset = this.wrapMessageAt('countReset', 0);
+		this.group = this.wrapMessageAt('group', 0);
+		this.groupCollapsed = this.wrapMessageAt('groupCollapsed', 0);
+
+		this.groupEnd = this.wrapSimple('groupEnd');
+		this.table = this.wrapExtra('table', ' <<table>>');
+		this.dir = this.wrapExtra('dir', ' <<dir>>');
+		this.clear = this.wrapExtra('clear', ' <<clear>>');
+	}
+
+	protected wrap<T extends keyof Omit<Console & { Console: any }, 'Console'>>(original: T): Function {
+		if (this.bind) {
+			return this.parent[original].bind(this.parent) as any;
+		} else {
+			return this.parent[original];
+		}
+	}
+
+	private wrapSimple<T extends keyof Omit<Console & { Console: any }, 'Console'>>(original: T): Console[T] {
+		return nameFunction('console:' + original, this.wrap(original) as any);
+	}
+
+	private wrapExtra<T extends keyof Omit<Console & { Console: any }, 'Console'>>(
+		original: T,
+		exMessage: string
+	): Console[T] {
+		const bindedFn = this.wrap(original);
+		return nameFunction('console:' + original, (...args: any[]) => {
+			this.log(exMessage);
+			bindedFn(...args);
+		});
+	}
+
+	protected createPrefix(message: string) {
+		let prefix = `[${this.title}]`;
+		if (message) {
+			prefix += `[${message}] `;
+		} else {
+			prefix += ' ';
+		}
+		return prefix;
+	}
+
+	private wrapMessageAt<T extends keyof Omit<Console & { Console: any }, 'Console'>>(
+		original: T,
+		messageLoc: number,
+		additionalPrefix?: string
+	): Console[T] {
+		let prefix = `[${this.title}]`;
+		if (additionalPrefix) {
+			prefix += `[${additionalPrefix}] `;
+		} else {
+			prefix += ' ';
+		}
+
+		const fn = this.wrap(original);
+
+		return nameFunction('console:' + original, (...args: any[]) => {
+			this.convertObjectArg(args, messageLoc);
+			this.processColorLabel(args, messageLoc, original, prefix);
+			fn(...args);
+		});
+	}
+
+	private convertObjectArg(args: any[], pos: number) {
+		const msg = args[pos];
+		if (args.length > pos) {
+			if (typeof msg === 'string') {
+				return;
+			}
+
+			args.splice(pos, 0, (isWeb ? ' %o' : ' %j').repeat(args.length - pos).substr(1));
+		} else {
+			args[pos] = '';
+		}
+	}
+
+	protected abstract processColorLabel(
+		normalizedArguments: any[],
+		messageLoc: number,
+		level: string,
+		prefix: string
+	): void;
+
+	protected uncolor(args: any[], pos: number, prefix: string, postfix: string) {
+		args[pos] = prefix + args[pos] + postfix;
+	}
+}

package/src/mapSet/customSet.ts

@@ -0,0 +1,91 @@
+/** Find the index of given item */
+export interface Finder<Type> {
+	(this: Type[], item: Type): number;
+}
+
+type MyFinder<Type> = (item: Type) => number;
+
+export function RegexpFinder(this: RegExp[], item: RegExp): number {
+	return this.findIndex((e) => e.toString() === item.toString());
+}
+
+/**
+ * Like a Set, but use custom compare function insteadof ===
+ */
+export class CustomSet<Type = string> {
+	protected registry: Type[];
+	private finder: MyFinder<Type>;
+
+	constructor(finder: Finder<Type> = Array.prototype.indexOf) {
+		this.registry = [];
+		this.finder = finder.bind(this.registry);
+	}
+
+	setFinder(finder: Finder<Type>) {
+		this.finder = finder.bind(this.registry);
+	}
+
+	has(item: Type): boolean {
+		return this.finder(item) !== -1;
+	}
+
+	add(item: Type): boolean {
+		const index = this.finder(item);
+		if (index === -1) {
+			this.registry.push(item);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * @returns all added values
+	 */
+	addAll(items: Type[]): Type[] {
+		return items.filter((e) => this.add(e));
+	}
+
+	delete(item: Type): boolean {
+		const index = this.finder(item);
+		if (index === -1) {
+			return false;
+		} else {
+			this.registry.splice(index, 1);
+			return true;
+		}
+	}
+
+	/**
+	 * @returns all deleted values
+	 */
+	deleteAll(items: Type[]): Type[] {
+		return items.filter((e) => this.delete(e));
+	}
+
+	clear() {
+		this.registry.length = 0;
+	}
+
+	get length() {
+		return this.registry.length;
+	}
+
+	get size() {
+		return this.registry.length;
+	}
+
+	[Symbol.iterator](): Iterator<Type> {
+		return this.registry[Symbol.iterator]();
+	}
+	keys(): Iterator<Type> {
+		return this.registry[Symbol.iterator]();
+	}
+	values(): Iterator<Type> {
+		return this.registry[Symbol.iterator]();
+	}
+
+	toArray() {
+		return this.registry.slice();
+	}
+}