@idlebox/common 1.4.0 → 1.4.2

package/src/error/pretty.ts

@@ -1,57 +1,146 @@
-import { isAbsolute } from '../path/isAbsolute';
-import { relativePath } from '../path/normalizePath';
-import { globalObject } from '../platform/globalObject';
-import { isNative } from '../platform/os';
+import { isAbsolute } from '../path/isAbsolute.js';
+import { relativePath } from '../path/normalizePath.js';
+import { globalObject } from '../platform/globalObject.js';
+import { isNative } from '../platform/os.js';
 
-const regNormal = /^\s+at ([^\/\s]+)(?: \[as ([^\]]+)])? \(((?:node|file):\/*)?([^:]+)(:\d+)?(:\d+)\)$/;
 const process = globalObject.process;
 const window = globalObject.window;
 
-const enum regNormalMatch {
-	fn = 1,
-	fnAlias,
-	fileSchema,
-	file,
-	row,
-	column,
-}
+const padding = /^(?<padding>\s*)at /.source;
+const func_call = /(?<func_name>(?:async )?[^\/\\\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 regFunctionOnly = /^\s+at ([^\/\\\s]+(?: \[as ([^\]]+)])?)$/;
+const regNormal = new RegExp(`${padding}${func_call}\\(${location}\\)$`);
+type TypeMatchNormal = 'padding' | TypeMatchNoFile | TypeMatchFileOnly;
 
-const enum regFunctionMatch {
-	fn = 1,
-	fnAlias,
-}
+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 regFileOnly = /^\s+at ([^:]+)(:\d+)?(:\d+)$/;
+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 enum regFileOnlyMatch {
-	file = 1,
-	row,
-	column,
+let root = process?.cwd?.() ?? window?.location?.domain ?? '/';
+export function setErrorLogRoot(_root: string) {
+	root = _root;
 }
 
-const regSimpleFrame = /^\s+at ([^(]+) \(<anonymous>\)$/;
+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[];
+}
 
-const enum regSimpleFrameMatch {
-	fn = 1,
+export interface IStructreStackLine {
+	invalid?: boolean;
+	toString(): string;
+	padding?: string;
+	func?: IFunction;
+	location?: IFileLocation;
+	eval?: IEvalDef;
 }
 
-let root = process?.cwd?.() ?? window?.location?.domain ?? '/';
+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;
+}
+function addLoc(ret: IStructreStackLine, m: Record<TypeMatchFileOnly, string>) {
+	const path = m.path1 || m.path2;
+	ret.location = {
+		schema: m.schema?.replace(/\/+$/, '') ?? '',
+		path: path,
+		line: parseInt(m.line),
+		column: parseInt(m.column),
+		isAbsolute: isAbsolute(path),
+	};
+}
 
-export function setErrorLogRoot(_root: string) {
-	root = _root;
+function addFunc(ret: IStructreStackLine, m: Record<TypeMatchNoFile, string>) {
+	ret.func = {
+		name: m.func_name,
+		alias: m.func_alias,
+	};
 }
 
-interface IInternalData {
-	raw?: string;
-	fn?: string;
-	as?: string;
-	file?: string;
-	fileSchema?: string; // 'node' | 'file';
-	line?: number;
-	col?: number;
-	abs?: boolean;
+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.padding = mNormal.padding;
+		addFunc(ret, mNormal);
+		addLoc(ret, mNormal);
+		return ret;
+	}
+
+	const mFile = matchLine<TypeMatchFileOnly>(line, regFileOnly);
+	if (mFile) {
+		ret.padding = mFile.padding;
+		addLoc(ret, mFile);
+		return ret;
+	}
+
+	const mNoFile = matchLine<TypeMatchNoFile>(line, regNoFile);
+	if (mNoFile) {
+		ret.padding = mNoFile.padding;
+		addFunc(ret, mNoFile);
+		return ret;
+	}
+
+	const mEval = matchLine<TypeMatchEval>(line.replaceAll(regEvalItem, ''), regEval);
+	if (mEval) {
+		ret.padding = mEval.padding;
+		addFunc(ret, mEval);
+		addLoc(ret, mEval);
+
+		ret.eval = {
+			eval_column: parseInt(mEval.eval_column),
+			eval_func: mEval.eval_func,
+			eval_line: parseInt(mEval.eval_line),
+			funcs: [],
+		};
+		for (const item of line.matchAll(regEvalItem)) {
+			ret.eval.funcs.push(item.groups!.func_name);
+		}
+		ret.eval.funcs.push(mEval.eval_func);
+
+		return ret;
+	}
+
+	ret.invalid = true;
+	return ret;
 }
 
 let notify_printed = false;
@@ -60,7 +149,7 @@ export function prettyPrintError(type: string, e: Error) {
 		return console.error(e.message);
 	}
 
-	if (globalObject.DISABLE_PRETTY_ERROR || process?.env?.DISABLE_PRETTY_ERROR) {
+	if (globalObject.DISABLE_PRETTY_ERROR || globalObject.process?.env?.DISABLE_PRETTY_ERROR) {
 		console.error('[%s] %s', type, e.stack || e.message);
 		return;
 	}
@@ -81,120 +170,125 @@ function red(s: string) {
 	return isNative ? `\x1B[38;5;9m${s}\x1B[0m` : s;
 }
 
-export function prettyFormatError(e: Error, withMessage = true) {
-	if (!e || typeof e.message !== 'string') {
-		console.error(e);
-		return red('Unknown Error') + '\n' + new Error().stack?.split('\n').slice(3).join('\n');
-	}
-	if (!e.stack) {
-		return red(e.message + '\n  No stack trace');
-	}
-	const stackStr = e.stack.replace(/(file|http|https):\/\//gi, '').split(/\n/g);
-
-	let first = stackStr.shift()!;
-	const stack: IInternalData[] = stackStr.map((line) => {
-		if (regNormal.test(line)) {
-			const m = regNormal.exec(line)!;
-			return {
-				fn: m[regNormalMatch.fn],
-				as: m[regNormalMatch.fnAlias],
-				fileSchema: m[regNormalMatch.fileSchema],
-				file: m[regNormalMatch.file],
-				line: parseInt(m[regNormalMatch.row].slice(1)),
-				col: parseInt(m[regNormalMatch.column].slice(1)),
-				abs: isAbsolute(m[regNormalMatch.file]),
-			};
-		} else if (regFunctionOnly.test(line)) {
-			const m = regFunctionOnly.exec(line)!;
-			return {
-				fn: m[regFunctionMatch.fn],
-				as: m[regFunctionMatch.fnAlias],
-				file: undefined,
-				line: undefined,
-				col: undefined,
-				abs: false,
-			};
-		} else if (regFileOnly.test(line)) {
-			const m = regFileOnly.exec(line)!;
-			return {
-				fn: undefined,
-				as: undefined,
-				file: m[regFileOnlyMatch.file],
-				line: parseInt(m[regFileOnlyMatch.row].slice(1)),
-				col: parseInt(m[regFileOnlyMatch.column].slice(1)),
-				abs: isAbsolute(m[regFileOnlyMatch.file]),
-			};
-		} else if (regSimpleFrame.test(line)) {
-			const m = regSimpleFrame.exec(line)!;
-			return {
-				fn: m[regSimpleFrameMatch.fn],
-				as: undefined,
-				file: '<anonymous>',
-				line: undefined,
-				col: undefined,
-				abs: false,
-			};
-		} else {
-			return { raw: line.replace(/^  /, '') };
-		}
-	});
-	const stackOutput = stack
-		.filter(ignoreSomeFiles)
+export function prettyFormatStack(stackLines: readonly string[]) {
+	const structured: IStructreStackLine[] = stackLines.map(parseStackLine);
+	return structured
+		.filter(skipSomeFrame)
 		.map(translateFunction)
-		.map(({ raw, fn, file, as, abs, line, col, fileSchema }) => {
+		.map((line) => {
 			let ret;
-			if (raw) {
-				return raw;
+			if (line.invalid) {
+				return line.toString();
 			}
+			const fn_name = line.func?.name;
 
-			if (abs) {
-				const isNodeModule = file?.includes('/node_modules/');
-				const color = fn ? (isNodeModule ? '4' : '14') : '8';
-				ret = `  at \x1b[38;5;${color}m`;
-				if (as && fn && fn.startsWith('Object.')) {
-					ret += as + ' [export]';
-				} else {
-					ret += formatFunctionName(fn, as);
-				}
-				ret += '\x1b[0m';
-				if (file) {
-					ret += ' (';
-					if (!isNodeModule) {
-						ret += '\x1b[38;5;2m';
+			if (!line.location?.isAbsolute || line.location.schema === 'node:') {
+				// no-path, relative path, node:
+				ret = '  at \x1B[2m';
+				if (line.func) {
+					ret += fn_name;
+					if (line.func.alias) {
+						ret += ` [${line.func.alias}]`;
 					}
-					ret += formatFileLine(fileSchema, file, line, col);
-					ret += '\x1B[0m)';
-				}
-			} else {
-				ret = '\x1B[2m  at ';
-				if (fn) {
-					ret += fn;
 				}
-				if (file === '<anonymous>') {
-				} else if (file) {
-					if (fn) {
+
+				if (line.location?.path === '<anonymous>') {
+				} else if (line.location?.path) {
+					if (fn_name) {
 						ret += ' (';
 					}
-					ret += formatFileLine(fileSchema, file, line, col);
-					if (fn) {
+					ret += formatFileLine(
+						line.location.schema,
+						line.location.path,
+						line.location.line,
+						line.location.column,
+					);
+					if (fn_name) {
 						ret += ')';
 					}
 				}
 				ret += '\x1B[0m';
+			} else {
+				const path = line.location.path;
+				const isNodeModule = path.includes('/node_modules/');
+				const fn_alias = line.func?.alias;
+
+				const color = fn_name ? (isNodeModule ? '14;2' : '14') : '8';
+				ret = `\x1b[0m  at \x1b[38;5;${color}m`;
+				if (fn_alias && fn_name && fn_name.startsWith('Object.')) {
+					ret += fn_alias + ' [export]';
+				} else {
+					ret += formatFunctionName(fn_name, fn_alias);
+				}
+				ret += '\x1b[0m';
+				if (line.eval) {
+					ret += `\x1b[2m(${line.eval.funcs.filter((e) => e !== '<anonymous>').join('->')})\x1b[0m`;
+				}
+
+				if (path) {
+					let color;
+					if (isNodeModule) {
+						color = '\x1b[38;5;237m';
+					} else {
+						color = '\x1b[38;5;2m';
+					}
+					ret += ' (' + color;
+					const file = formatFileLine(line.location.schema, path, line.location.line, line.location.column);
+					const lastNmPos = file.lastIndexOf('/node_modules/');
+					if (lastNmPos >= 0) {
+						ret += file.slice(0, lastNmPos + 14);
+
+						let nextSlash = file.indexOf('/', lastNmPos + 15);
+						const scopePkg = file[lastNmPos + 14] === '@';
+						if (scopePkg) {
+							nextSlash = file.indexOf('/', nextSlash + 1);
+						}
+
+						ret += '\x1B[0m';
+						ret += file.slice(lastNmPos + 14, nextSlash);
+						ret += color;
+						ret += file.slice(nextSlash);
+					} else {
+						ret += file;
+					}
+					ret += '\x1B[0m)';
+				}
 			}
 			return ret;
 		});
+}
+
+interface IError {
+	readonly code?: any;
+	readonly message?: any;
+	readonly stack?: string;
+}
+export function prettyFormatError(e: IError, withMessage = true) {
+	if (!e || !e.stack) {
+		if (withMessage) {
+			let msg = e?.message || 'Unknown Error';
+
+			return red(msg + '\n  No stack trace');
+		} else {
+			return red('  No stack trace');
+		}
+	}
+
+	let stackLines = e.stack.split(/\n/g);
+
+	let first = 'Unknown Error';
+	if (/^\S/.test(stackLines[0])) {
+		first = stackLines.shift()!;
+	}
 
 	if (withMessage) {
-		if ((e as any).code) {
-			first = first.replace(/^(\S+):/, (_, name) => {
-				return `${name}(code ${(e as any).code}):`;
-			});
+		if (e.code) {
+			first = first.replace(/^(\S+):/, `$1(code ${e.code}):`);
 		}
 
-		return first + '\n' + stackOutput.join('\n');
+		return first + '\n' + prettyFormatStack(stackLines).join('\n');
 	} else {
-		return stackOutput.join('\n');
+		return prettyFormatStack(stackLines).join('\n');
 	}
 }
 
@@ -205,10 +299,15 @@ function formatFileLine(schema: string | undefined, file: string, row?: number,
 	if (schema !== 'node:') {
 		try {
 			rel = relativePath(root, file);
-			if (rel.startsWith('..')) {
-				rel = file;
-			} else if (!rel.startsWith('.')) {
+			if (rel[0] !== '.') {
 				rel = './' + rel;
+			} else if (rel[1] === '.') {
+				if (file.length < rel.length) {
+					rel = file;
+				}
+			}
+			if (rel[0] === '.') {
+				schema = '';
 			}
 		} catch (e: any) {
 			if (!alert) {
@@ -236,36 +335,53 @@ function formatFunctionName(fn?: string, as?: string) {
 			return fn;
 		}
 	} else {
-		return '[anonymous]';
+		return '<anonymous>';
 	}
 }
 
-function translateFunction(data: IInternalData): IInternalData {
-	if (!data.fn) {
+function translateFunction(data: IStructreStackLine): IStructreStackLine {
+	if (!data.func?.name) {
 		return data;
 	}
-	if (data.fn === 'Timeout._onTimeout') {
-		data.fn = 'setTimeout';
+	if (data.func.name === 'Timeout._onTimeout') {
+		data.func.name = 'setTimeout';
+	}
+	if (data.func.name === 'Immediate._onImmediate') {
+		data.func.name = 'setImmediate';
 	}
-	if (data.fn.startsWith('Timeout.') && data.as === '_onTimeout') {
-		data.fn = 'setTimeout->' + data.fn.slice(8);
-		delete data.as;
+	if (data.func.name === 'process.processTicksAndRejections') {
+		data.func.name = 'process.nextTick';
+	}
+	if (data.func.name.startsWith('Timeout.') && data.func.alias === '_onTimeout') {
+		data.func.name = 'setTimeout->' + data.func.name.slice(8);
+		delete data.func.alias;
 	}
 	return data;
 }
 
-function ignoreSomeFiles({ file }: IInternalData): boolean {
-	if (!file) {
+/**
+ *
+ */
+function skipSomeFrame({ location }: IStructreStackLine): boolean {
+	if (!location?.path) {
 		return true;
 	}
-	if (file === 'internal/timers.js') {
-		return false;
-	}
-	if (file.startsWith('internal/modules/cjs/loader')) {
-		return false;
+
+	if (location.schema === 'node:') {
+		if (location.path.startsWith('internal/timers')) {
+			return false;
+		} else if (location.path === 'internal/modules/cjs/loader') {
+			return false;
+		} else if (location.path === 'internal/modules/esm/loader') {
+			return false;
+		} else if (location.path === 'internal/modules/run_main') {
+			return false;
+		} else if (location.path === 'internal/modules/esm/module_job') {
+			return false;
+		}
 	}
-	if (!file.includes('/')) {
-		if (file.startsWith('_stream_')) {
+	if (!location.path.includes('/')) {
+		if (location.path.startsWith('_stream_')) {
 			return false;
 		}
 	}

package/src/function/asyncCallbackList.ts

@@ -1,4 +1,4 @@
-import { nameFunction } from './functionName';
+import { nameFunction } from './functionName.js';
 
 export interface MyAsyncCallback<Argument extends unknown[]> {
 	displayName?: string;

package/src/function/callbackList.ts

@@ -1,4 +1,4 @@
-import { nameFunction } from './functionName';
+import { nameFunction } from './functionName.js';
 
 export interface MyCallback<Argument extends unknown[]> {
 	displayName?: string;

package/src/function/delayCallbackList.ts

@@ -1,4 +1,4 @@
-import { nameFunction } from './functionName';
+import { nameFunction } from './functionName.js';
 
 export interface MyDelayCallback<Argument extends unknown[]> {
 	displayName?: string;

package/src/lifecycle/dispose/disposableEvent.ts

@@ -1,4 +1,4 @@
-import { IDisposable } from './lifecycle';
+import { IDisposable } from './lifecycle.js';
 
 declare const AbortController: new () => any;
 

package/src/lifecycle/dispose/disposedError.ts

@@ -1,6 +1,6 @@
-import { tryInspect } from '../../debugging/tryInspect';
-import { getErrorFrame } from '../../error/getFrame';
-import { prettyFormatError } from '../../error/pretty';
+import { tryInspect } from '../../debugging/tryInspect.js';
+import { getErrorFrame } from '../../error/getFrame.js';
+import { prettyFormatError } from '../../error/pretty.js';
 
 /**
  * Error when call dispose() twice

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

@@ -1,7 +1,7 @@
-import { convertCatchedError } from '../../error/convertUnknown';
-import { Emitter, EventRegister } from '../event/event';
-import { DisposedError } from './disposedError';
-import { IAsyncDisposable, IDisposableEvents } from './lifecycle';
+import { convertCatchedError } from '../../error/convertUnknown.js';
+import { Emitter, EventRegister } from '../event/event.js';
+import { DisposedError } from './disposedError.js';
+import { IAsyncDisposable, IDisposableEvents } from './lifecycle.js';
 
 /**
  * Async version of Disposable

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

@@ -1,7 +1,7 @@
-import { globalSingletonStrong } from '../../platform/globalSingleton';
-import { createSymbol } from '../../platform/globalSymbol';
-import { IDisposable } from './lifecycle';
-import { AsyncDisposable } from './lifecycle.async';
+import { globalSingletonStrong } from '../../platform/globalSingleton.js';
+import { createSymbol } from '../../platform/globalSymbol.js';
+import { IDisposable } from './lifecycle.js';
+import { AsyncDisposable } from './lifecycle.async.js';
 
 const symbol = createSymbol('lifecycle', 'application');
 

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

@@ -1,6 +1,6 @@
-import { Emitter, EventRegister } from '../event/event';
-import { DisposedError } from './disposedError';
-import { IDisposable, IDisposableEvents } from './lifecycle';
+import { Emitter, EventRegister } from '../event/event.js';
+import { DisposedError } from './disposedError.js';
+import { IDisposable, IDisposableEvents } from './lifecycle.js';
 
 export abstract class DisposableOnce implements IDisposable {
 	private _disposed?: Error;

package/src/lifecycle/dispose/lifecycle.ts

@@ -1,4 +1,4 @@
-import { EventRegister } from '../event/event';
+import { EventRegister } from '../event/event.js';
 
 /**
  * @private