@idlebox/common 1.5.13 → 1.5.15

package/src/error/stack-parser.v8.ts

@@ -0,0 +1,157 @@
+import { isAbsolute } from '../path/isAbsolute.js';
+
+const padding = /^(?<padding> {4})at /.source;
+const func_call = /(?<func_name>(?:(?:async|new) )?[^/\\\s]+) (?:\[as (?<func_alias>[^\]]+)] )?/.source;
+//                              xxxx.yyyyy [as eval]
+const line_column = /(?::(?<line>\d+))?(?::(?<column>\d+))?/.source;
+const locationEsm = /(?<schema>node:|file:\/\/|https?:\/\/)?(?<path2>[^:]+)/.source;
+//                        node:internal/modules/cjs/loader.js:883:14
+const locationCjs = /(?<path1>(?:\/|[a-zA-Z]:)[^:]+)/.source;
+//                          /data/to/file.js
+const location = `(?:${locationCjs}|${locationEsm})${line_column}`;
+
+const regNormal = new RegExp(`${padding}${func_call}\\(${location}\\)$`);
+type TypeMatchNormal = 'padding' | TypeMatchNoFile | TypeMatchFileOnly;
+
+const regNoFile = new RegExp(`${padding}${func_call}$`);
+type TypeMatchNoFile = 'padding' | 'func_name' | 'func_alias';
+
+const regFileOnly = new RegExp(`${padding}${location}$`);
+type TypeMatchFileOnly = 'padding' | 'schema' | 'path1' | 'path2' | 'line' | 'column';
+
+const regEvalItem = new RegExp(`\\(eval at ${func_call}`, 'g');
+const eval_source = /, (?<eval_func>[\S]+):(?<eval_line>\d+):(?<eval_column>\d+)/.source;
+const regEval = new RegExp(`${padding}${func_call}.*?\\(${location}\\)+${eval_source}`);
+type TypeMatchEval = 'padding' | TypeMatchNoFile | TypeMatchFileOnly | 'eval_func' | 'eval_line' | 'eval_column';
+
+const regInvalid = new RegExp(`${padding}(?<content>.+) \\(${location}\\)$`);
+type TypeMatchInvalid = TypeMatchFileOnly | 'content';
+
+export function parseStackString(stack: string) {
+	return stack.split('\n').map(parseStackLine);
+}
+
+interface IFunction {
+	name: string;
+	alias?: string;
+}
+interface IFileLocation {
+	path: string;
+	schema: string; // '' | 'node:' | 'file:' | 'http:' | 'https:';
+	line: number;
+	column: number;
+	isAbsolute: boolean;
+}
+interface IEvalDef {
+	eval_func: string;
+	eval_line: number;
+	eval_column: number;
+	funcs: string[];
+}
+
+export interface IStructreStackLine {
+	invalid?: boolean;
+	special?: boolean;
+	toString(): string;
+	padding?: string;
+	func?: IFunction;
+	location?: IFileLocation;
+	eval?: IEvalDef;
+	_matches?: RegExp;
+}
+
+function matchLine<T extends string>(line: string, reg: RegExp): null | Record<T, string> {
+	const m = reg.exec(line);
+	if (!m) {
+		return null;
+	}
+	return m.groups as any;
+}
+const endingSlashes = /\/+$/;
+function addLoc(ret: IStructreStackLine, m: Record<TypeMatchFileOnly, string>) {
+	const path = m.path1 || m.path2;
+	ret.location = {
+		schema: m.schema?.replace(endingSlashes, '') ?? '',
+		path: path,
+		line: Number.parseInt(m.line, 10),
+		column: Number.parseInt(m.column, 10),
+		isAbsolute: isAbsolute(path),
+	};
+}
+
+function addFunc(ret: IStructreStackLine, m: Record<TypeMatchNoFile, string>) {
+	ret.func = {
+		name: m.func_name,
+		alias: m.func_alias,
+	};
+}
+
+export function parseStackLine(line: string): IStructreStackLine {
+	const __raw = line;
+	const ret: IStructreStackLine = {
+		invalid: false,
+		toString() {
+			return __raw;
+		},
+	};
+	Object.assign(ret, { __raw });
+
+	const mNormal = matchLine<TypeMatchNormal>(line, regNormal);
+	if (mNormal) {
+		ret._matches = regNormal;
+		ret.padding = mNormal.padding;
+		addFunc(ret, mNormal);
+		addLoc(ret, mNormal);
+		return ret;
+	}
+
+	const mFile = matchLine<TypeMatchFileOnly>(line, regFileOnly);
+	if (mFile) {
+		ret._matches = regFileOnly;
+		ret.padding = mFile.padding;
+		addLoc(ret, mFile);
+		return ret;
+	}
+
+	const mNoFile = matchLine<TypeMatchNoFile>(line, regNoFile);
+	if (mNoFile) {
+		ret._matches = regNoFile;
+		ret.padding = mNoFile.padding;
+		addFunc(ret, mNoFile);
+		return ret;
+	}
+
+	const mEval = matchLine<TypeMatchEval>(line.replaceAll(regEvalItem, ''), regEval);
+	if (mEval) {
+		ret._matches = regEval;
+		ret.padding = mEval.padding;
+		addFunc(ret, mEval);
+		addLoc(ret, mEval);
+
+		ret.eval = {
+			eval_column: Number.parseInt(mEval.eval_column, 10),
+			eval_func: mEval.eval_func,
+			eval_line: Number.parseInt(mEval.eval_line, 10),
+			funcs: [],
+		};
+		for (const item of line.matchAll(regEvalItem)) {
+			// biome-ignore lint/style/noNonNullAssertion: 有匹配必然有 groups
+			ret.eval.funcs.push(item.groups!['func_name']);
+		}
+		ret.eval.funcs.push(mEval.eval_func);
+
+		return ret;
+	}
+
+	const mInv = matchLine<TypeMatchInvalid>(line, regInvalid);
+	if (mInv) {
+		const path = mInv.path1 || mInv.path2;
+		if (path.endsWith(mInv.content)) {
+			addLoc(ret, mInv);
+			return ret;
+		}
+	}
+
+	ret.invalid = true;
+	return ret;
+}

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

@@ -1,3 +1,4 @@
+import { defineInspectMethod } from '../../../debugging/inspect.js';
 import { functionName, nameObject } from '../../../debugging/object-with-name.js';
 import { dispose_name } from '../debug.js';
 import type { IAsyncDisposable, IDisposable } from '../disposable.js';
@@ -7,12 +8,17 @@ import type { IAsyncDisposable, IDisposable } from '../disposable.js';
  * @public
  */
 export function functionToDisposable<RT>(fn: () => RT): RT extends Promise<any> ? IAsyncDisposable : IDisposable {
-	return {
-		get displayName() {
-			return `disposeFn(${functionName(fn)})`;
+	return defineInspectMethod(
+		{
+			get displayName() {
+				return `disposeFn(${functionName(fn)})`;
+			},
+			dispose: fn,
+		} as any,
+		(_depth, options) => {
+			return options.stylize(`[FunctionDisposable ${functionName(fn)}]`, 'special');
 		},
-		dispose: fn,
-	} as any;
+	);
 }
 
 /**

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

@@ -1,3 +1,4 @@
+import { defineInspectMethod } from '../../../debugging/inspect.js';
 import { objectName } from '../../../debugging/object-with-name.js';
 import type { IAsyncDisposable } from '../disposable.js';
 
@@ -13,26 +14,31 @@ type ClosableAsync = {
 export function closableToDisposable<T extends ClosableAsync>(closable: T): IAsyncDisposable {
 	const promised = closable.close.length === 0;
 
-	return {
-		get displayName() {
-			return `closable(${objectName(closable) || 'unknown'})`;
-		},
-		dispose(): Promise<void> {
-			if (promised) {
-				return Promise.resolve(closable.close()).then(() => undefined);
-			} else {
-				return new Promise<void>((resolve, reject) => {
-					closable.close((error) => {
-						if (error) {
-							reject(error);
-						} else {
-							resolve();
-						}
+	return defineInspectMethod(
+		{
+			get displayName() {
+				return `closable(${objectName(closable) || 'unknown'})`;
+			},
+			dispose(): Promise<void> {
+				if (promised) {
+					return Promise.resolve(closable.close()).then(() => undefined);
+				} else {
+					return new Promise<void>((resolve, reject) => {
+						closable.close((error) => {
+							if (error) {
+								reject(error);
+							} else {
+								resolve();
+							}
+						});
 					});
-				});
-			}
+				}
+			},
+		},
+		(_depth, options) => {
+			return options.stylize(`[ClosableDisposable ${objectName(closable) || 'unknown'}]`, 'special');
 		},
-	};
+	);
 }
 
 type EndableAsync = {
@@ -47,24 +53,29 @@ type EndableAsync = {
 export function endableToDisposable<T extends EndableAsync>(endable: T): IAsyncDisposable {
 	const promised = endable.end.length === 0;
 
-	return {
-		get displayName() {
-			return `endable(${objectName(endable) || 'unknown'})`;
-		},
-		dispose(): Promise<void> {
-			if (promised) {
-				return Promise.resolve(endable.end()).then(() => undefined);
-			} else {
-				return new Promise<void>((resolve, reject) => {
-					return endable.end((error) => {
-						if (error) {
-							reject(error);
-						} else {
-							resolve();
-						}
+	return defineInspectMethod(
+		{
+			get displayName() {
+				return `endable(${objectName(endable) || 'unknown'})`;
+			},
+			dispose(): Promise<void> {
+				if (promised) {
+					return Promise.resolve(endable.end()).then(() => undefined);
+				} else {
+					return new Promise<void>((resolve, reject) => {
+						return endable.end((error) => {
+							if (error) {
+								reject(error);
+							} else {
+								resolve();
+							}
+						});
 					});
-				});
-			}
+				}
+			},
+		},
+		(_depth, options) => {
+			return options.stylize(`[EndableDisposable ${objectName(endable) || 'unknown'}]`, 'special');
 		},
-	};
+	);
 }

package/src/lifecycle/dispose/disposable.ts

@@ -1,3 +1,4 @@
+import { defineInspectMethod } from '../../debugging/inspect.js';
 import type { MaybeNamed } from '../../debugging/object-with-name.js';
 import { createStackTraceHolder, type StackTraceHolder } from '../../error/stack-trace.js';
 import { Emitter } from '../event/event.js';
@@ -57,13 +58,25 @@ export abstract class AbstractEnhancedDisposable<Async extends boolean> implemen
 			this.displayName = displayName;
 		}
 
-		this._logger = _debug_dispose.extend(this.displayName || 'disposable');
+		this._logger = defineInspectMethod(_debug_dispose.extend(this.displayName || 'disposable'), () => {
+			return `[Function debug]`;
+		});
 
 		this._onPostDispose.handle(() => {
 			this._onPostDispose.dispose();
 		});
 		this._disposables.push(this._onBeforeDispose);
 		this._disposables.push(this._onDisposeError);
+
+		if (
+			this.constructor.name === 'EnhancedAsyncDisposable' ||
+			this.constructor.name === 'UnorderedAsyncDisposable' ||
+			this.constructor.name === 'EnhancedDisposable'
+		) {
+			defineInspectMethod(this, (_depth: number, options: any) => {
+				return options.stylize(`[${this.displayName}]`, 'special');
+			});
+		}
 	}
 
 	/**

package/src/lifecycle/event/event.ts

@@ -1,4 +1,5 @@
 import { Exit } from '@idlebox/errors';
+import { defineInspectMethod, inspectSymbol } from '../../debugging/inspect.js';
 import { nameObject, objectName } from '../../debugging/object-with-name.js';
 import { createStackTraceHolder } from '../../error/stack-trace.js';
 import { functionToDisposable } from '../dispose/bridges/function.js';
@@ -6,6 +7,8 @@ import type { IDisposable } from '../dispose/disposable.js';
 import { DisposedError } from '../dispose/disposedError.js';
 import type { EventHandler, EventRegister, IEventEmitter } from './type.js';
 
+const anonymousName = 'AnonymousEmitter';
+
 /**
  * @public
  */
@@ -14,7 +17,7 @@ export class Emitter<T = unknown> implements IEventEmitter<T> {
 	private executing = false;
 	private _something_change_during_call = false;
 
-	constructor(public readonly displayName: string = 'AnonymousEmitter') {
+	constructor(public readonly displayName: string = anonymousName) {
 		this.handle = Object.defineProperties(this.handle.bind(this), {
 			once: {
 				get: () => this.once.bind(this),
@@ -26,6 +29,9 @@ export class Emitter<T = unknown> implements IEventEmitter<T> {
 				get: () => this._disposed,
 			},
 		});
+		defineInspectMethod(this.handle, (_depth, options) => {
+			return options.stylize(`[EmitterRegister ${this.displayName}]`, 'special');
+		});
 	}
 
 	public listenerCount() {
@@ -181,6 +187,17 @@ export class Emitter<T = unknown> implements IEventEmitter<T> {
 
 	readonly [Symbol.dispose] = this.dispose;
 
+	[inspectSymbol](_depth: number, options: any) {
+		let r = `${options.stylize(this.constructor.name, 'name')} {`;
+		if (this.displayName !== anonymousName) {
+			r += ` ${options.stylize(this.displayName, 'string')},`;
+		}
+		r += ` listeners: ${options.stylize(this.listenerCount(), 'number')}`;
+
+		r += ' }';
+		return r;
+	}
+
 	private requireNotExecuting() {
 		if (this.executing) {
 			throw new Error('conflict state, emitter is firing');

package/src/schedule/interval.ts

@@ -1,3 +1,4 @@
+import { inspectSymbol } from '../debugging/inspect.js';
 import { objectName } from '../debugging/object-with-name.js';
 import type { IDisposable } from '../lifecycle/dispose/disposable.js';
 import { EnhancedDisposable } from '../lifecycle/dispose/sync-disposable.js';
@@ -61,4 +62,15 @@ export class Interval extends EnhancedDisposable {
 		if (this.timer) this.timer.dispose();
 		return super.dispose();
 	}
+
+	[inspectSymbol](depth: number, options: any, inspect: any) {
+		if (depth < 0) {
+			return options.stylize(`[Interval ${this.ms}ms]`, 'special');
+		}
+		let r = `${options.stylize(this.constructor.name, 'name')} ${options.stylize(`${this.ms}`, 'number')}ms`;
+		const padding = ' '.repeat(2);
+		const inner = inspect(this._emitter, options, inspect).replace(/\n/g, `\n${padding}`);
+		r += ` {\n${padding}onTick: ${inner}\n}`;
+		return r;
+	}
 }