@idlebox/common 1.4.19 → 1.4.21

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

@@ -1,66 +0,0 @@
-import { globalSingletonStrong } from '../../platform/globalSingleton.js';
-import { createSymbol } from '../../platform/globalSymbol.js';
-import { _debug_dispose } from './debug.js';
-import { AsyncDisposable, AsyncDisposableUnordered } from './lifecycle.async.js';
-import type { IDisposable } from './lifecycle.js';
-
-const symbol = createSymbol('lifecycle', 'application');
-
-function create(): AsyncDisposable {
-	return new AsyncDisposableUnordered('global');
-}
-
-const logger = _debug_dispose.extend('global');
-
-/**
- * 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
- *
- * Never throws when child object dispose failed
- */
-export function ensureDisposeGlobal() {
-	const obj = globalSingletonStrong<AsyncDisposable>(symbol);
-	if (obj && !obj.hasDisposed) {
-		return Promise.resolve(obj.dispose());
-	}
-	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?.hasDisposed) {
-		throw new Error('global already disposed.');
-	}
-	if (obj) {
-		return Promise.resolve(obj.dispose());
-	}
-	if (logger.enabled) logger(`dispose global (not exists)`);
-	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 override async dispose(): Promise<void> {
-		return super.dispose().finally(() => {
-			this.done();
-		});
-	}
-}

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

@@ -1,133 +0,0 @@
-import { createStackTraceHolder, type StackTraceHolder } from '../../error/stackTrace.js';
-import { Emitter, type EventRegister } from '../event/event.js';
-import { _debug_dispose, dispose_name } from './debug.js';
-import { DisposedError } from './disposedError.js';
-import type { IDisposable, IDisposableEvents } from './lifecycle.js';
-
-interface _DOMDisposable {
-	[Symbol.dispose](): void;
-}
-
-export abstract class DisposableOnce implements IDisposable {
-	private _disposed?: StackTraceHolder;
-
-	public get hasDisposed() {
-		return !!this._disposed;
-	}
-	public dispose(): void {
-		if (this._disposed) {
-			console.warn(new DisposedError(this, this._disposed).message);
-			return;
-		}
-		this._disposed = createStackTraceHolder('disposed', this.dispose);
-		this._dispose();
-	}
-
-	toWeb(): _DOMDisposable {
-		return this;
-	}
-	static fromWeb(disposable: _DOMDisposable): IDisposable {
-		if (!('dispose' in disposable)) {
-			Object.assign(disposable, { dispose: disposable[Symbol.dispose] });
-		}
-		return disposable as unknown as IDisposable;
-	}
-	[Symbol.dispose]() {
-		this.dispose();
-	}
-	protected abstract _dispose(): void;
-}
-
-/**
- * Standalone disposable class, can use as instance or base class.
- */
-export class Disposable implements IDisposable, IDisposableEvents {
-	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?: StackTraceHolder;
-
-	/** @internal */
-	readonly #logger;
-	constructor(public readonly displayName?: string) {
-		this.#logger = _debug_dispose.extend(this.displayName || 'disposable');
-	}
-
-	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 IDisposable>(d: T): T;
-	public _register<T extends IDisposable & IDisposableEvents>(d: T, autoDereference?: boolean): T;
-	public _register<T extends IDisposable | (IDisposable & IDisposableEvents)>(d: T, autoDereference?: boolean): T {
-		if (this.#logger.enabled) this.#logger(`register ${dispose_name(d)}`);
-		this.assertNotDisposed();
-		this._disposables.unshift(d);
-		if (autoDereference) {
-			(d as IDisposableEvents).onBeforeDispose(() => {
-				this._unregister(d);
-			});
-		}
-		return d;
-	}
-
-	public _unregister(d: IDisposable) {
-		if (this.#logger.enabled) this.#logger(`unregister ${dispose_name(d)}`);
-		return this._disposables.splice(this._disposables.indexOf(d), 1).length > 0;
-	}
-
-	toWeb(): _DOMDisposable {
-		return this;
-	}
-	static fromWeb(disposable: _DOMDisposable): IDisposable {
-		if (!('dispose' in disposable)) {
-			Object.assign(disposable, { dispose: disposable[Symbol.dispose] });
-		}
-		return disposable as unknown as IDisposable;
-	}
-	[Symbol.dispose]() {
-		this.dispose();
-	}
-
-	public dispose(): void {
-		if (this._disposed) {
-			console.warn(new DisposedError(this, this._disposed).message);
-			return;
-		}
-		this._onBeforeDispose.fireNoError();
-		this._disposed = createStackTraceHolder('disposed', this.dispose);
-
-		this._disposables.push(this._onBeforeDispose);
-		this._disposables.push(this._onDisposeError);
-		for (const item of this._disposables.values()) {
-			try {
-				if (this.#logger.enabled) this.#logger(`dispose ${dispose_name(item)}`);
-				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,94 +0,0 @@
-import type { MaybeNamed } from '../../function/functionName.js';
-import type { EventRegister } from '../event/event.js';
-
-/**
- * @private
- */
-export interface IDisposableEvents {
-	onDisposeError: EventRegister<Error>;
-	onBeforeDispose: EventRegister<void>;
-	readonly hasDisposed: boolean;
-}
-
-/** @public */
-export interface IDisposable extends MaybeNamed {
-	dispose(): void;
-
-	// [Symbol.dispose]?(): void;
-	/** @internal do not use/rely */
-	// [Symbol.asyncDispose]?(): Promise<void>;
-}
-
-/** @public */
-export interface IAsyncDisposable extends MaybeNamed {
-	dispose(): void | Promise<void>;
-
-	// [Symbol.dispose]?(): void | Promise<void>;
-	// [Symbol.asyncDispose]?(): void | Promise<void>;
-}
-
-/**
- * Convert "dispose function" to disposable object
- * @public
- */
-export function toDisposable(fn_or_obj: Disposable | AsyncDisposable | (() => void)): IDisposable {
-	if (typeof fn_or_obj === 'function') {
-		return {
-			get displayName() {
-				return `toDisposable(${fn_or_obj.name || 'anonymous'})`;
-			},
-			dispose: fn_or_obj,
-		};
-	} else if (Symbol.dispose in fn_or_obj) {
-		const obj = fn_or_obj as any;
-		return {
-			get displayName() {
-				return `toDisposable[Disposable](${obj.displayName || obj.name || obj.constructor.name || 'unknown'})`;
-			},
-			dispose() {
-				fn_or_obj[Symbol.dispose]();
-			},
-		};
-	} else if (Symbol.asyncDispose in fn_or_obj) {
-		const obj = fn_or_obj as any;
-		return {
-			get displayName() {
-				return `toDisposable[AsyncDisposable](${obj.displayName || obj.name || obj.constructor.name || 'unknown'})`;
-			},
-			dispose() {
-				return fn_or_obj[Symbol.asyncDispose]();
-			},
-		};
-	} else {
-		throw new TypeError('toDisposable: expected function or object with Symbol.dispose or Symbol.asyncDispose', {
-			cause: fn_or_obj,
-		});
-	}
-}
-
-type ClosableAsync = { close(): Promise<any> } & MaybeNamed;
-type ClosableSync = { close(cb: (e?: Error) => void): void } & MaybeNamed;
-export function closableToDisposable(closable: ClosableAsync | ClosableSync): IDisposable {
-	const promised = closable.close.length === 0;
-
-	return {
-		get displayName() {
-			return `closableToDisposable[AsyncDisposable](${closable.displayName || closable.name || closable.constructor.name || 'unknown'})`;
-		},
-		dispose() {
-			if (promised) {
-				return (closable as ClosableAsync).close();
-			} else {
-				return new Promise<void>((resolve, reject) => {
-					return (closable as ClosableSync).close((error) => {
-						if (error) {
-							reject(error);
-						} else {
-							resolve();
-						}
-					});
-				});
-			}
-		},
-	};
-}

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/timeout/timeoutError.ts

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

package/src/promise/finishAllPromise.ts

@@ -1,50 +0,0 @@
-/** @deprecated */
-export interface PromiseResultArray<T> {
-	count: number;
-	fulfilledResult: T[];
-	fulfilled: number[];
-	rejectedResult: Error[];
-	rejected: number[];
-}
-
-/**
- * @deprecated Use Promise.allSettled instead
- */
-export function finishAllPromise<T>(ps: Promise<T>[]) {
-	return new Promise<PromiseResultArray<T>>((resolve) => {
-		const fulfilledResult: T[] = [];
-		const rejectedResult: Error[] = [];
-		const fulfilled: number[] = [];
-		const rejected: number[] = [];
-		let last = ps.length;
-
-		const toDone = () => {
-			if (last === 0) {
-				resolve({
-					count: ps.length,
-					fulfilledResult,
-					fulfilled,
-					rejectedResult,
-					rejected,
-				});
-			}
-		};
-
-		ps.forEach((p, index) => {
-			p.then(
-				(t) => {
-					fulfilledResult[index] = t;
-					fulfilled.push(index);
-					last--;
-					toDone();
-				},
-				(e) => {
-					rejectedResult[index] = e;
-					rejected.push(index);
-					last--;
-					toDone();
-				},
-			);
-		});
-	});
-}

package/src/promise/timeoutPromiseCollection.ts

@@ -1,22 +0,0 @@
-import { TimeoutError } from '../lifecycle/timeout/timeoutError.js';
-import { PromiseCollection } from './promiseCollection.js';
-
-export class TimeoutPromiseCollection extends PromiseCollection {
-	constructor(private readonly defaultTimeoutMs = 50000) {
-		super();
-	}
-
-	override create(id: string, timeoutMs: number = this.defaultTimeoutMs, timeoutMsg?: string) {
-		const p = super.create(id);
-
-		const to = setTimeout(() => {
-			this.error(id, new TimeoutError(timeoutMs, timeoutMsg));
-		}, timeoutMs);
-
-		p.finally(() => {
-			clearTimeout(to);
-		});
-
-		return p;
-	}
-}

package/src/reflection/classes/hookClass.ts

@@ -1,47 +0,0 @@
-export const hookClassSymbol = Symbol('@gongt/hookClass');
-
-interface IConstructorOf<T> extends Object {
-	new (...args: any[]): T;
-}
-
-interface IHooks<T, TC> {
-	afterConstruct?: ((obj: T) => void)[];
-	beforeConstruct?: ((obj: TC) => T | undefined)[];
-}
-
-export function hookClass<TC extends IConstructorOf<T>, T>(target: TC): IHooks<T, TC> {
-	if ((target as any)[hookClassSymbol]) {
-		return (target as any)[hookClassSymbol];
-	}
-
-	const hooks = {} as IHooks<T, TC>;
-
-	const proxyTarget = new Proxy(target, {
-		construct(target: any, argArray: any): object {
-			if (hooks.beforeConstruct) {
-				for (const beforeCb of hooks.beforeConstruct) {
-					const ret = beforeCb(target);
-					if (ret) {
-						return ret as any;
-					}
-				}
-			}
-			const d = new target(...argArray);
-			if (hooks.afterConstruct) {
-				for (const afterCb of hooks.afterConstruct) {
-					afterCb(d);
-				}
-			}
-			return d;
-		},
-	});
-
-	Object.defineProperty(proxyTarget, hookClassSymbol, {
-		value: hooks,
-		enumerable: false,
-		configurable: false,
-		writable: false,
-	});
-
-	return hooks;
-}

package/src/reflection/methods/initOnRead.ts

@@ -1,11 +0,0 @@
-import { type InitFunc, initOnRead } from '../../object/initOnRead.js';
-
-/**
- * Decorater version of `initOnRead`
- * @see initOnRead
- */
-export function init<O, T extends keyof O>(init: InitFunc<O, O[T]>): PropertyDecorator {
-	return ((target: O, propertyKey: T) => {
-		initOnRead<O, T>(target, propertyKey, init);
-	}) as any;
-}