@eggjs/tegg-common-util 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/index.d.ts

@@ -1,13 +1,136 @@
-import { MapUtil } from "./MapUtil.js";
-import { NameUtil } from "./NameUtil.js";
-import { EdgeMeta, Graph, GraphNode, GraphPath } from "./Graph.js";
-import { ObjectUtils } from "./ObjectUtils.js";
-import { FSUtil } from "./FSUtil.js";
-import { StackUtil } from "./StackUtil.js";
-import { ProxyUtil } from "./ProxyUtil.js";
-import { ModuleConfigUtil, ModuleReferenceConfigHelp } from "./ModuleConfig.js";
-import { ModuleConfig, ModuleConfigs } from "./ModuleConfigs.js";
-import { TimerUtil } from "./TimerUtil.js";
 import "reflect-metadata";
+import { EggProtoImplClass, GraphNodeObj, InlineModuleReferenceConfig, ModuleConfig, ModuleConfig as ModuleConfig$1, ModuleConfigHolder, ModuleReference, ModuleReferenceConfig, NpmModuleReferenceConfig, ReadModuleReferenceOptions } from "@eggjs/tegg-types";
 export * from "@eggjs/tegg-types/common";
-export { EdgeMeta, FSUtil, Graph, GraphNode, GraphPath, MapUtil, ModuleConfig, ModuleConfigUtil, ModuleConfigs, ModuleReferenceConfigHelp, NameUtil, ObjectUtils, ProxyUtil, StackUtil, TimerUtil };
+
+//#region src/MapUtil.d.ts
+declare class MapUtil {
+  static getOrStore<K, V>(map: Map<K, V>, key: K, value: V): V;
+}
+//#endregion
+//#region src/NameUtil.d.ts
+declare class NameUtil {
+  static getClassName(constructor: Function): string;
+}
+//#endregion
+//#region src/Graph.d.ts
+declare const inspect: unique symbol;
+interface EdgeMeta {
+  equal(meta: EdgeMeta): boolean;
+  toString(): string;
+}
+declare class GraphNode<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
+  val: T;
+  toNodeMap: Map<string, {
+    node: GraphNode<T, M>;
+    meta?: M;
+  }>;
+  fromNodeMap: Map<string, {
+    node: GraphNode<T, M>;
+    meta?: M;
+  }>;
+  constructor(val: T);
+  get id(): string;
+  addToVertex(node: GraphNode<T, M>, meta?: M): boolean;
+  addFromVertex(node: GraphNode<T, M>, meta?: M): boolean;
+  [inspect](): {
+    val: T;
+    toNodes: {
+      node: GraphNode<T, M>;
+      meta?: M;
+    }[];
+    fromNodes: {
+      node: GraphNode<T, M>;
+      meta?: M;
+    }[];
+  };
+  toJSON(): {
+    val: T;
+    toNodes: {
+      node: GraphNode<T, M>;
+      meta?: M;
+    }[];
+    fromNodes: {
+      node: GraphNode<T, M>;
+      meta?: M;
+    }[];
+  };
+  toString(): string;
+}
+declare class GraphPath<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
+  nodeIdMap: Map<string, number>;
+  nodes: Array<{
+    node: GraphNode<T, M>;
+    meta?: M;
+  }>;
+  pushVertex(node: GraphNode<T, M>, meta?: M): boolean;
+  popVertex(): void;
+  toString(): string;
+  [inspect](): string;
+}
+declare class Graph<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
+  nodes: Map<string, GraphNode<T, M>>;
+  addVertex(node: GraphNode<T, M>): boolean;
+  addEdge(from: GraphNode<T, M>, to: GraphNode<T, M>, meta?: M): boolean;
+  findToNode(id: string, meta: M): GraphNode<T, M> | undefined;
+  appendVertexToPath(node: GraphNode<T, M>, accessPath: GraphPath<T, M>, meta?: M): boolean;
+  loopPath(): GraphPath<T, M> | undefined;
+  accessNode(node: GraphNode<T, M>, nodes: Array<GraphNode<T, M>>, accessed: boolean[], res: Array<GraphNode<T, M>>): void;
+  sort(): Array<GraphNode<T, M>>;
+}
+//#endregion
+//#region src/ObjectUtils.d.ts
+declare class ObjectUtils {
+  static getProperties(obj: object): string[];
+  static getFunctionArgNameList(func: Function): string[];
+  static getConstructorArgNameList(clazz: EggProtoImplClass): string[];
+}
+//#endregion
+//#region src/FSUtil.d.ts
+declare class FSUtil {
+  static fileExists(filePath: string): Promise<boolean>;
+}
+//#endregion
+//#region src/StackUtil.d.ts
+declare class StackUtil {
+  static getCalleeFromStack(withLine: boolean, stackIndex?: number): string;
+}
+//#endregion
+//#region src/ProxyUtil.d.ts
+declare class ProxyUtil {
+  static safeProxy<T extends object>(obj: T, getter: (obj: T, p: PropertyKey) => any): T;
+}
+//#endregion
+//#region src/ModuleConfig.d.ts
+declare class ModuleReferenceConfigHelp {
+  static isInlineModuleReference(moduleReference: ModuleReferenceConfig): moduleReference is InlineModuleReferenceConfig;
+  static isNpmModuleReference(moduleReference: ModuleReferenceConfig): moduleReference is NpmModuleReferenceConfig;
+}
+declare class ModuleConfigUtil {
+  #private;
+  static configNames: string[] | undefined;
+  static setConfigNames(configNames: string[] | undefined): void;
+  static readModuleReference(baseDir: string, options?: ReadModuleReferenceOptions): readonly ModuleReference[];
+  private static readModuleReferenceFromModuleJson;
+  private static readModuleReferenceFromScan;
+  static readModuleFromNodeModules(baseDir: string): ModuleReference[];
+  static resolveModuleDir(moduleDir: string, baseDir?: string): string;
+  private static getModuleName;
+  static readModuleName(baseDir: string, moduleDir: string): Promise<string>;
+  static readModuleNameSync(moduleDir: string, baseDir?: string): string;
+  static loadModuleConfig(moduleDir: string, baseDir?: string, env?: string): Promise<ModuleConfig$1>;
+  static loadModuleConfigSync(moduleDir: string, baseDir?: string, env?: string): ModuleConfig$1;
+}
+//#endregion
+//#region src/ModuleConfigs.d.ts
+declare class ModuleConfigs {
+  readonly inner: Record<string, ModuleConfigHolder>;
+  constructor(inner: Record<string, ModuleConfigHolder>);
+  get(moduleName: string): ModuleConfig | undefined;
+}
+//#endregion
+//#region src/TimerUtil.d.ts
+declare class TimerUtil {
+  static sleep(ms: number): Promise<void>;
+}
+//#endregion
+export { EdgeMeta, FSUtil, Graph, GraphNode, GraphPath, MapUtil, type ModuleConfig, ModuleConfigUtil, ModuleConfigs, ModuleReferenceConfigHelp, NameUtil, ObjectUtils, ProxyUtil, StackUtil, TimerUtil };

package/dist/index.js

@@ -1,15 +1,481 @@
-import { MapUtil } from "./MapUtil.js";
-import { NameUtil } from "./NameUtil.js";
-import { Graph, GraphNode, GraphPath } from "./Graph.js";
-import { ObjectUtils } from "./ObjectUtils.js";
-import { FSUtil } from "./FSUtil.js";
-import { StackUtil } from "./StackUtil.js";
-import { ProxyUtil } from "./ProxyUtil.js";
-import { ModuleConfigUtil, ModuleReferenceConfigHelp } from "./ModuleConfig.js";
-import { ModuleConfigs } from "./ModuleConfigs.js";
-import { TimerUtil } from "./TimerUtil.js";
 import "reflect-metadata";
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { debuglog } from "node:util";
+import assert from "node:assert";
+import fs$1, { promises } from "node:fs";
+import path from "node:path";
+import { extend } from "extend2";
+import { globbySync } from "globby";
+import { load } from "js-yaml";
+import { importResolve } from "@eggjs/utils";
 
 export * from "@eggjs/tegg-types/common"
 
+//#region src/MapUtil.ts
+var MapUtil = class {
+	static getOrStore(map, key, value) {
+		if (!map.has(key)) map.set(key, value);
+		return map.get(key);
+	}
+};
+
+//#endregion
+//#region src/NameUtil.ts
+var NameUtil = class {
+	static getClassName(constructor) {
+		return constructor.name[0].toLowerCase() + constructor.name.substring(1);
+	}
+};
+
+//#endregion
+//#region src/Graph.ts
+const inspect = Symbol.for("nodejs.util.inspect.custom");
+var GraphNode = class {
+	val;
+	toNodeMap = /* @__PURE__ */ new Map();
+	fromNodeMap = /* @__PURE__ */ new Map();
+	constructor(val) {
+		this.val = val;
+	}
+	get id() {
+		return this.val.id;
+	}
+	addToVertex(node, meta) {
+		if (this.toNodeMap.has(node.id)) return false;
+		this.toNodeMap.set(node.id, {
+			node,
+			meta
+		});
+		return true;
+	}
+	addFromVertex(node, meta) {
+		if (this.fromNodeMap.has(node.id)) return false;
+		this.fromNodeMap.set(node.id, {
+			node,
+			meta
+		});
+		return true;
+	}
+	[inspect]() {
+		return this.toJSON();
+	}
+	toJSON() {
+		return {
+			val: this.val,
+			toNodes: Array.from(this.toNodeMap.values()),
+			fromNodes: Array.from(this.fromNodeMap.values())
+		};
+	}
+	toString() {
+		return this.val.toString();
+	}
+};
+var GraphPath = class {
+	nodeIdMap = /* @__PURE__ */ new Map();
+	nodes = [];
+	pushVertex(node, meta) {
+		const val = this.nodeIdMap.get(node.id) || 0;
+		this.nodeIdMap.set(node.id, val + 1);
+		this.nodes.push({
+			node,
+			meta
+		});
+		return val === 0;
+	}
+	popVertex() {
+		const nodeHandler = this.nodes.pop();
+		if (nodeHandler) {
+			const val = this.nodeIdMap.get(nodeHandler.node.id);
+			this.nodeIdMap.set(nodeHandler.node.id, val - 1);
+		}
+	}
+	toString() {
+		return this.nodes.reduce((p, c) => {
+			let msg = "";
+			if (c.meta) msg += ` ${c.meta.toString()} -> `;
+			else if (p.length) msg += " -> ";
+			msg += c.node.val.toString();
+			p.push(msg);
+			return p;
+		}, new Array()).join("");
+	}
+	[inspect]() {
+		return this.toString();
+	}
+};
+var Graph = class {
+	nodes = /* @__PURE__ */ new Map();
+	addVertex(node) {
+		if (this.nodes.has(node.id)) return false;
+		this.nodes.set(node.id, node);
+		return true;
+	}
+	addEdge(from, to, meta) {
+		to.addFromVertex(from, meta);
+		return from.addToVertex(to, meta);
+	}
+	findToNode(id, meta) {
+		const node = this.nodes.get(id);
+		if (!node) return void 0;
+		for (const { node: toNode, meta: edgeMeta } of node.toNodeMap.values()) if (edgeMeta && meta.equal(edgeMeta)) return toNode;
+	}
+	appendVertexToPath(node, accessPath, meta) {
+		if (!accessPath.pushVertex(node, meta)) return false;
+		for (const toNode of node.toNodeMap.values()) if (!this.appendVertexToPath(toNode.node, accessPath, toNode.meta)) return false;
+		accessPath.popVertex();
+		return true;
+	}
+	loopPath() {
+		const accessPath = new GraphPath();
+		const nodes = Array.from(this.nodes.values());
+		for (const node of nodes) if (!this.appendVertexToPath(node, accessPath)) return accessPath;
+	}
+	accessNode(node, nodes, accessed, res) {
+		const index = nodes.indexOf(node);
+		if (accessed[index]) return;
+		if (!node.toNodeMap.size) {
+			accessed[nodes.indexOf(node)] = true;
+			res.push(node);
+			return;
+		}
+		for (const toNode of node.toNodeMap.values()) this.accessNode(toNode.node, nodes, accessed, res);
+		accessed[nodes.indexOf(node)] = true;
+		res.push(node);
+	}
+	sort() {
+		const res = [];
+		const nodes = Array.from(this.nodes.values());
+		const accessed = [];
+		for (let i = 0; i < nodes.length; ++i) accessed.push(false);
+		for (let i = 0; i < nodes.length; ++i) {
+			const node = nodes[i];
+			this.accessNode(node, nodes, accessed, res);
+		}
+		return res;
+	}
+};
+
+//#endregion
+//#region src/ObjectUtils.ts
+var ObjectUtils = class {
+	static getProperties(obj) {
+		const properties = [];
+		do
+			for (const property of Object.getOwnPropertyNames(obj)) properties.push(property);
+		while ((obj = Object.getPrototypeOf(obj)) && obj !== Object.prototype);
+		return properties;
+	}
+	static getFunctionArgNameList(func) {
+		if (func.length === 0) return [];
+		let sourcecode = func.toString();
+		sourcecode = sourcecode.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/(.)*/g, "").replace(/{[\s\S]*}/, "").replace(/=>/g, "").trim();
+		let argsString = sourcecode.substring(sourcecode.indexOf("(") + 1, sourcecode.length - 1);
+		argsString = argsString.replace(/=\([\s\S]*\)/g, "");
+		return argsString.split(",").map((arg) => {
+			return arg.replace(/=[\s\S]*/g, "").trim();
+		}).filter((arg) => arg.length);
+	}
+	static getConstructorArgNameList(clazz) {
+		if (clazz.length === 0) return [];
+		const constructorMatch = clazz.toString().match(/constructor\s*\(([^)]+)\)/);
+		if (!constructorMatch) return [];
+		return constructorMatch[1].split(",").map((param) => param.trim()).map((param) => param.match(/(\w+)\s*(?=\s*(?:=|\/\/|\s*$))/)).filter(Boolean).map((match) => match[0].trim());
+	}
+};
+
+//#endregion
+//#region src/FSUtil.ts
+var FSUtil = class {
+	static async fileExists(filePath) {
+		try {
+			await fs.access(filePath);
+		} catch {
+			return false;
+		}
+		return true;
+	}
+};
+
+//#endregion
+//#region src/StackUtil.ts
+const debug = debuglog("@eggjs/tegg-common-util/StackUtil");
+/**
+* Capture call site stack from v8.
+* https://github.com/v8/v8/wiki/Stack-Trace-API
+*/
+function prepareObjectStackTrace(_, stack) {
+	return stack;
+}
+var StackUtil = class {
+	static getCalleeFromStack(withLine, stackIndex) {
+		stackIndex = stackIndex === void 0 ? 2 : stackIndex;
+		const limit = Error.stackTraceLimit;
+		const prep = Error.prepareStackTrace;
+		Error.prepareStackTrace = prepareObjectStackTrace;
+		Error.stackTraceLimit = 10;
+		const obj = { stack: [] };
+		Error.captureStackTrace(obj);
+		if (debug.enabled) debug("call stack: %o", obj.stack.map((callSite$1) => callSite$1.getFileName() ?? "<anonymous>").join("\n"));
+		const callSite = obj.stack[stackIndex];
+		let fileName;
+		if (callSite) {
+			fileName = callSite.getFileName();
+			if (fileName?.startsWith("file://")) fileName = fileURLToPath(fileName);
+		}
+		Error.prepareStackTrace = prep;
+		Error.stackTraceLimit = limit;
+		/* istanbul ignore if */
+		if (!callSite || !fileName) return "<anonymous>";
+		if (!withLine) return fileName;
+		return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
+	}
+};
+
+//#endregion
+//#region src/ProxyUtil.ts
+var ProxyUtil = class {
+	static safeProxy(obj, getter) {
+		return new Proxy(obj, { get(target, p) {
+			if (Object.prototype[p]) return Reflect.get(target, p);
+			return getter(target, p);
+		} });
+	}
+};
+
+//#endregion
+//#region src/ModuleConfig.ts
+var ModuleReferenceConfigHelp = class {
+	static isInlineModuleReference(moduleReference) {
+		return !!moduleReference.path;
+	}
+	static isNpmModuleReference(moduleReference) {
+		return !!moduleReference.package;
+	}
+};
+const DEFAULT_READ_MODULE_REF_OPTS = { deep: 10 };
+var ModuleConfigUtil = class ModuleConfigUtil {
+	static configNames;
+	static setConfigNames(configNames) {
+		ModuleConfigUtil.configNames = configNames;
+	}
+	static readModuleReference(baseDir, options) {
+		const configDir = path.join(baseDir, "config");
+		const moduleJsonPath = path.join(configDir, "module.json");
+		if (fs$1.existsSync(moduleJsonPath)) return this.readModuleReferenceFromModuleJson(configDir, moduleJsonPath, options?.cwd || baseDir);
+		return this.readModuleReferenceFromScan(baseDir, options);
+	}
+	static readModuleReferenceFromModuleJson(configDir, moduleJsonPath, cwd) {
+		const moduleJsonContent = fs$1.readFileSync(moduleJsonPath, "utf8");
+		const moduleJson = JSON.parse(moduleJsonContent);
+		const moduleReferenceList = [];
+		for (const moduleReferenceConfig of moduleJson) {
+			let moduleReference;
+			if (ModuleReferenceConfigHelp.isNpmModuleReference(moduleReferenceConfig)) {
+				const options = cwd ? { paths: [cwd] } : {};
+				const pkgJson = path.posix.join(moduleReferenceConfig.package, "package.json");
+				const file = importResolve(pkgJson, options);
+				const modulePath = path.dirname(file);
+				moduleReference = {
+					path: modulePath,
+					name: ModuleConfigUtil.readModuleNameSync(modulePath)
+				};
+			} else if (ModuleReferenceConfigHelp.isInlineModuleReference(moduleReferenceConfig)) {
+				const modulePath = path.join(configDir, moduleReferenceConfig.path);
+				moduleReference = {
+					path: modulePath,
+					name: ModuleConfigUtil.readModuleNameSync(modulePath)
+				};
+			} else throw new Error("unknown type of module reference config: " + JSON.stringify(moduleReferenceConfig));
+			moduleReferenceList.push(moduleReference);
+		}
+		return moduleReferenceList;
+	}
+	static readModuleReferenceFromScan(baseDir, options) {
+		const ref = [];
+		const realOptions = Object.assign({}, DEFAULT_READ_MODULE_REF_OPTS, options);
+		const packagePaths = globbySync([
+			"**/package.json",
+			"!**/node_modules",
+			"!**/+(.*)/**",
+			"!**/coverage",
+			...realOptions.extraFilePattern || []
+		], {
+			cwd: baseDir,
+			deep: realOptions.deep
+		});
+		const moduleDirSet = /* @__PURE__ */ new Set();
+		for (const packagePath of packagePaths) {
+			const absolutePkgPath = path.join(baseDir, packagePath);
+			let realPkgPath;
+			try {
+				realPkgPath = fs$1.realpathSync(absolutePkgPath);
+			} catch {
+				continue;
+			}
+			const moduleDir = path.dirname(realPkgPath);
+			if (moduleDirSet.has(moduleDir)) continue;
+			moduleDirSet.add(moduleDir);
+			let name;
+			try {
+				name = this.readModuleNameSync(moduleDir);
+			} catch {
+				continue;
+			}
+			ref.push({
+				path: moduleDir,
+				name
+			});
+		}
+		const moduleReferences = this.readModuleFromNodeModules(baseDir);
+		for (const moduleReference of moduleReferences) {
+			const moduleBasePath = path.basename(moduleReference.path);
+			moduleDirSet.forEach((modulePath) => {
+				if (path.basename(modulePath) === moduleBasePath) throw new Error("duplicate import of module reference: " + moduleBasePath);
+			});
+			ref.push({
+				path: moduleReference.path,
+				name: moduleReference.name
+			});
+		}
+		return ref;
+	}
+	static readModuleFromNodeModules(baseDir) {
+		const ref = [];
+		let pkgContent;
+		try {
+			pkgContent = fs$1.readFileSync(path.join(baseDir, "package.json"), "utf8");
+		} catch {
+			return [];
+		}
+		const pkg = JSON.parse(pkgContent);
+		for (const dependencyKey of Object.keys(pkg.dependencies || {})) {
+			let packageJsonPath;
+			try {
+				packageJsonPath = importResolve(`${dependencyKey}/package.json`, { paths: [baseDir] });
+			} catch {
+				continue;
+			}
+			const absolutePkgPath = path.dirname(packageJsonPath);
+			const realPkgPath = fs$1.realpathSync(absolutePkgPath);
+			try {
+				const name = this.readModuleNameSync(realPkgPath);
+				ref.push({
+					path: realPkgPath,
+					name
+				});
+			} catch {
+				continue;
+			}
+		}
+		return ref;
+	}
+	static resolveModuleDir(moduleDir, baseDir) {
+		if (path.isAbsolute(moduleDir)) return moduleDir;
+		assert(baseDir, "baseDir is required");
+		return path.join(baseDir, "config", moduleDir);
+	}
+	static getModuleName(pkg) {
+		assert(pkg.eggModule && pkg.eggModule.name, "eggModule.name not found in package.json");
+		return pkg.eggModule.name;
+	}
+	static async readModuleName(baseDir, moduleDir) {
+		moduleDir = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
+		const pkgContent = await promises.readFile(path.join(moduleDir, "package.json"), "utf8");
+		const pkg = JSON.parse(pkgContent);
+		return ModuleConfigUtil.getModuleName(pkg);
+	}
+	static readModuleNameSync(moduleDir, baseDir) {
+		moduleDir = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
+		const pkgContent = fs$1.readFileSync(path.join(moduleDir, "package.json"), "utf8");
+		const pkg = JSON.parse(pkgContent);
+		return ModuleConfigUtil.getModuleName(pkg);
+	}
+	static async loadModuleConfig(moduleDir, baseDir, env) {
+		const modulePath = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
+		let configNames;
+		if (env) configNames = ["module", `module.${env}`];
+		else configNames = ModuleConfigUtil.configNames || ["module"];
+		const target = {};
+		for (const configName of configNames) {
+			let config = await ModuleConfigUtil.#loadOne(modulePath, configName);
+			if (configName === "module.default" && !config) config = await ModuleConfigUtil.#loadOne(modulePath, "module");
+			if (config) extend(true, target, config);
+		}
+		return target;
+	}
+	static async #loadOne(moduleDir, configName) {
+		const yamlConfigPath = path.join(moduleDir, `${configName}.yml`);
+		let config = await ModuleConfigUtil.#loadYaml(yamlConfigPath);
+		if (!config) {
+			const jsonConfigPath = path.join(moduleDir, `${configName}.json`);
+			config = await ModuleConfigUtil.#loadJson(jsonConfigPath);
+		}
+		return config;
+	}
+	static async #loadJson(moduleJsonPath) {
+		if (!await FSUtil.fileExists(moduleJsonPath)) return;
+		const moduleJsonContent = await promises.readFile(moduleJsonPath, "utf8");
+		return JSON.parse(moduleJsonContent).config;
+	}
+	static async #loadYaml(moduleYamlPath) {
+		if (!await FSUtil.fileExists(moduleYamlPath)) return;
+		const moduleYamlContent = await promises.readFile(moduleYamlPath, "utf8");
+		return load(moduleYamlContent);
+	}
+	static loadModuleConfigSync(moduleDir, baseDir, env) {
+		const modulePath = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
+		let configNames;
+		if (env) configNames = ["module", `module.${env}`];
+		else configNames = ModuleConfigUtil.configNames || ["module"];
+		const target = {};
+		for (const configName of configNames) {
+			let config = ModuleConfigUtil.#loadOneSync(modulePath, configName);
+			if (configName === "module.default" && !config) config = ModuleConfigUtil.#loadOneSync(modulePath, "module");
+			if (config) extend(true, target, config);
+		}
+		return target;
+	}
+	static #loadOneSync(moduleDir, configName) {
+		const yamlConfigPath = path.join(moduleDir, `${configName}.yml`);
+		let config = ModuleConfigUtil.#loadYamlSync(yamlConfigPath);
+		if (!config) {
+			const jsonConfigPath = path.join(moduleDir, `${configName}.json`);
+			config = ModuleConfigUtil.#loadJsonSync(jsonConfigPath);
+		}
+		return config;
+	}
+	static #loadJsonSync(moduleJsonPath) {
+		if (!fs$1.existsSync(moduleJsonPath)) return;
+		const moduleJsonContent = fs$1.readFileSync(moduleJsonPath, "utf8");
+		return JSON.parse(moduleJsonContent).config;
+	}
+	static #loadYamlSync(moduleYamlPath) {
+		if (!fs$1.existsSync(moduleYamlPath)) return;
+		const moduleYamlContent = fs$1.readFileSync(moduleYamlPath, "utf8");
+		return load(moduleYamlContent);
+	}
+};
+
+//#endregion
+//#region src/ModuleConfigs.ts
+var ModuleConfigs = class {
+	inner;
+	constructor(inner) {
+		this.inner = inner;
+	}
+	get(moduleName) {
+		return this.inner[moduleName]?.config;
+	}
+};
+
+//#endregion
+//#region src/TimerUtil.ts
+var TimerUtil = class {
+	static async sleep(ms) {
+		await new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+
+//#endregion
 export { FSUtil, Graph, GraphNode, GraphPath, MapUtil, ModuleConfigUtil, ModuleConfigs, ModuleReferenceConfigHelp, NameUtil, ObjectUtils, ProxyUtil, StackUtil, TimerUtil };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eggjs/tegg-common-util",
   "description": "common util for tegg",
-  "version": "4.0.0-beta.6",
+  "version": "4.0.0-beta.8",
   "keywords": [
     "egg",
     "typescript",
@@ -36,7 +36,7 @@
     "extend2": "^4.0.0",
     "globby": "^14.1.0",
     "js-yaml": "4.1.0",
-    "@eggjs/tegg-types": "4.0.0-beta.6"
+    "@eggjs/tegg-types": "4.0.0-beta.8"
   },
   "publishConfig": {
     "access": "public"

package/dist/FSUtil.d.ts

@@ -1,6 +0,0 @@
-//#region src/FSUtil.d.ts
-declare class FSUtil {
-  static fileExists(filePath: string): Promise<boolean>;
-}
-//#endregion
-export { FSUtil };

package/dist/FSUtil.js

@@ -1,16 +0,0 @@
-import fs from "node:fs/promises";
-
-//#region src/FSUtil.ts
-var FSUtil = class {
-	static async fileExists(filePath) {
-		try {
-			await fs.access(filePath);
-		} catch {
-			return false;
-		}
-		return true;
-	}
-};
-
-//#endregion
-export { FSUtil };

package/dist/Graph.d.ts

@@ -1,69 +0,0 @@
-import { GraphNodeObj } from "@eggjs/tegg-types";
-
-//#region src/Graph.d.ts
-declare const inspect: unique symbol;
-interface EdgeMeta {
-  equal(meta: EdgeMeta): boolean;
-  toString(): string;
-}
-declare class GraphNode<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
-  val: T;
-  toNodeMap: Map<string, {
-    node: GraphNode<T, M>;
-    meta?: M;
-  }>;
-  fromNodeMap: Map<string, {
-    node: GraphNode<T, M>;
-    meta?: M;
-  }>;
-  constructor(val: T);
-  get id(): string;
-  addToVertex(node: GraphNode<T, M>, meta?: M): boolean;
-  addFromVertex(node: GraphNode<T, M>, meta?: M): boolean;
-  [inspect](): {
-    val: T;
-    toNodes: {
-      node: GraphNode<T, M>;
-      meta?: M;
-    }[];
-    fromNodes: {
-      node: GraphNode<T, M>;
-      meta?: M;
-    }[];
-  };
-  toJSON(): {
-    val: T;
-    toNodes: {
-      node: GraphNode<T, M>;
-      meta?: M;
-    }[];
-    fromNodes: {
-      node: GraphNode<T, M>;
-      meta?: M;
-    }[];
-  };
-  toString(): string;
-}
-declare class GraphPath<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
-  nodeIdMap: Map<string, number>;
-  nodes: Array<{
-    node: GraphNode<T, M>;
-    meta?: M;
-  }>;
-  pushVertex(node: GraphNode<T, M>, meta?: M): boolean;
-  popVertex(): void;
-  toString(): string;
-  [inspect](): string;
-}
-declare class Graph<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
-  nodes: Map<string, GraphNode<T, M>>;
-  addVertex(node: GraphNode<T, M>): boolean;
-  addEdge(from: GraphNode<T, M>, to: GraphNode<T, M>, meta?: M): boolean;
-  findToNode(id: string, meta: M): GraphNode<T, M> | undefined;
-  appendVertexToPath(node: GraphNode<T, M>, accessPath: GraphPath<T, M>, meta?: M): boolean;
-  loopPath(): GraphPath<T, M> | undefined;
-  accessNode(node: GraphNode<T, M>, nodes: Array<GraphNode<T, M>>, accessed: boolean[], res: Array<GraphNode<T, M>>): void;
-  sort(): Array<GraphNode<T, M>>;
-}
-//#endregion
-export { EdgeMeta, Graph, GraphNode, GraphPath };

package/dist/Graph.js

@@ -1,129 +0,0 @@
-//#region src/Graph.ts
-const inspect = Symbol.for("nodejs.util.inspect.custom");
-var GraphNode = class {
-	val;
-	toNodeMap = /* @__PURE__ */ new Map();
-	fromNodeMap = /* @__PURE__ */ new Map();
-	constructor(val) {
-		this.val = val;
-	}
-	get id() {
-		return this.val.id;
-	}
-	addToVertex(node, meta) {
-		if (this.toNodeMap.has(node.id)) return false;
-		this.toNodeMap.set(node.id, {
-			node,
-			meta
-		});
-		return true;
-	}
-	addFromVertex(node, meta) {
-		if (this.fromNodeMap.has(node.id)) return false;
-		this.fromNodeMap.set(node.id, {
-			node,
-			meta
-		});
-		return true;
-	}
-	[inspect]() {
-		return this.toJSON();
-	}
-	toJSON() {
-		return {
-			val: this.val,
-			toNodes: Array.from(this.toNodeMap.values()),
-			fromNodes: Array.from(this.fromNodeMap.values())
-		};
-	}
-	toString() {
-		return this.val.toString();
-	}
-};
-var GraphPath = class {
-	nodeIdMap = /* @__PURE__ */ new Map();
-	nodes = [];
-	pushVertex(node, meta) {
-		const val = this.nodeIdMap.get(node.id) || 0;
-		this.nodeIdMap.set(node.id, val + 1);
-		this.nodes.push({
-			node,
-			meta
-		});
-		return val === 0;
-	}
-	popVertex() {
-		const nodeHandler = this.nodes.pop();
-		if (nodeHandler) {
-			const val = this.nodeIdMap.get(nodeHandler.node.id);
-			this.nodeIdMap.set(nodeHandler.node.id, val - 1);
-		}
-	}
-	toString() {
-		return this.nodes.reduce((p, c) => {
-			let msg = "";
-			if (c.meta) msg += ` ${c.meta.toString()} -> `;
-			else if (p.length) msg += " -> ";
-			msg += c.node.val.toString();
-			p.push(msg);
-			return p;
-		}, new Array()).join("");
-	}
-	[inspect]() {
-		return this.toString();
-	}
-};
-var Graph = class {
-	nodes = /* @__PURE__ */ new Map();
-	addVertex(node) {
-		if (this.nodes.has(node.id)) return false;
-		this.nodes.set(node.id, node);
-		return true;
-	}
-	addEdge(from, to, meta) {
-		to.addFromVertex(from, meta);
-		return from.addToVertex(to, meta);
-	}
-	findToNode(id, meta) {
-		const node = this.nodes.get(id);
-		if (!node) return void 0;
-		for (const { node: toNode, meta: edgeMeta } of node.toNodeMap.values()) if (edgeMeta && meta.equal(edgeMeta)) return toNode;
-	}
-	appendVertexToPath(node, accessPath, meta) {
-		if (!accessPath.pushVertex(node, meta)) return false;
-		for (const toNode of node.toNodeMap.values()) if (!this.appendVertexToPath(toNode.node, accessPath, toNode.meta)) return false;
-		accessPath.popVertex();
-		return true;
-	}
-	loopPath() {
-		const accessPath = new GraphPath();
-		const nodes = Array.from(this.nodes.values());
-		for (const node of nodes) if (!this.appendVertexToPath(node, accessPath)) return accessPath;
-	}
-	accessNode(node, nodes, accessed, res) {
-		const index = nodes.indexOf(node);
-		if (accessed[index]) return;
-		if (!node.toNodeMap.size) {
-			accessed[nodes.indexOf(node)] = true;
-			res.push(node);
-			return;
-		}
-		for (const toNode of node.toNodeMap.values()) this.accessNode(toNode.node, nodes, accessed, res);
-		accessed[nodes.indexOf(node)] = true;
-		res.push(node);
-	}
-	sort() {
-		const res = [];
-		const nodes = Array.from(this.nodes.values());
-		const accessed = [];
-		for (let i = 0; i < nodes.length; ++i) accessed.push(false);
-		for (let i = 0; i < nodes.length; ++i) {
-			const node = nodes[i];
-			this.accessNode(node, nodes, accessed, res);
-		}
-		return res;
-	}
-};
-
-//#endregion
-export { Graph, GraphNode, GraphPath };

package/dist/MapUtil.d.ts

@@ -1,6 +0,0 @@
-//#region src/MapUtil.d.ts
-declare class MapUtil {
-  static getOrStore<K, V>(map: Map<K, V>, key: K, value: V): V;
-}
-//#endregion
-export { MapUtil };

package/dist/MapUtil.js

@@ -1,10 +0,0 @@
-//#region src/MapUtil.ts
-var MapUtil = class {
-	static getOrStore(map, key, value) {
-		if (!map.has(key)) map.set(key, value);
-		return map.get(key);
-	}
-};
-
-//#endregion
-export { MapUtil };

package/dist/ModuleConfig.d.ts

@@ -1,24 +0,0 @@
-import { InlineModuleReferenceConfig, ModuleConfig, ModuleReference, ModuleReferenceConfig, NpmModuleReferenceConfig, ReadModuleReferenceOptions } from "@eggjs/tegg-types";
-
-//#region src/ModuleConfig.d.ts
-declare class ModuleReferenceConfigHelp {
-  static isInlineModuleReference(moduleReference: ModuleReferenceConfig): moduleReference is InlineModuleReferenceConfig;
-  static isNpmModuleReference(moduleReference: ModuleReferenceConfig): moduleReference is NpmModuleReferenceConfig;
-}
-declare class ModuleConfigUtil {
-  #private;
-  static configNames: string[] | undefined;
-  static setConfigNames(configNames: string[] | undefined): void;
-  static readModuleReference(baseDir: string, options?: ReadModuleReferenceOptions): readonly ModuleReference[];
-  private static readModuleReferenceFromModuleJson;
-  private static readModuleReferenceFromScan;
-  static readModuleFromNodeModules(baseDir: string): ModuleReference[];
-  static resolveModuleDir(moduleDir: string, baseDir?: string): string;
-  private static getModuleName;
-  static readModuleName(baseDir: string, moduleDir: string): Promise<string>;
-  static readModuleNameSync(moduleDir: string, baseDir?: string): string;
-  static loadModuleConfig(moduleDir: string, baseDir?: string, env?: string): Promise<ModuleConfig>;
-  static loadModuleConfigSync(moduleDir: string, baseDir?: string, env?: string): ModuleConfig;
-}
-//#endregion
-export { ModuleConfigUtil, ModuleReferenceConfigHelp };

package/dist/ModuleConfig.js

@@ -1,224 +0,0 @@
-import { FSUtil } from "./FSUtil.js";
-import assert from "node:assert";
-import fs, { promises } from "node:fs";
-import path from "node:path";
-import { extend } from "extend2";
-import { globbySync } from "globby";
-import { load } from "js-yaml";
-import { importResolve } from "@eggjs/utils";
-
-//#region src/ModuleConfig.ts
-var ModuleReferenceConfigHelp = class {
-	static isInlineModuleReference(moduleReference) {
-		return !!moduleReference.path;
-	}
-	static isNpmModuleReference(moduleReference) {
-		return !!moduleReference.package;
-	}
-};
-const DEFAULT_READ_MODULE_REF_OPTS = { deep: 10 };
-var ModuleConfigUtil = class ModuleConfigUtil {
-	static configNames;
-	static setConfigNames(configNames) {
-		ModuleConfigUtil.configNames = configNames;
-	}
-	static readModuleReference(baseDir, options) {
-		const configDir = path.join(baseDir, "config");
-		const moduleJsonPath = path.join(configDir, "module.json");
-		if (fs.existsSync(moduleJsonPath)) return this.readModuleReferenceFromModuleJson(configDir, moduleJsonPath, options?.cwd || baseDir);
-		return this.readModuleReferenceFromScan(baseDir, options);
-	}
-	static readModuleReferenceFromModuleJson(configDir, moduleJsonPath, cwd) {
-		const moduleJsonContent = fs.readFileSync(moduleJsonPath, "utf8");
-		const moduleJson = JSON.parse(moduleJsonContent);
-		const moduleReferenceList = [];
-		for (const moduleReferenceConfig of moduleJson) {
-			let moduleReference;
-			if (ModuleReferenceConfigHelp.isNpmModuleReference(moduleReferenceConfig)) {
-				const options = cwd ? { paths: [cwd] } : {};
-				const pkgJson = path.posix.join(moduleReferenceConfig.package, "package.json");
-				const file = importResolve(pkgJson, options);
-				const modulePath = path.dirname(file);
-				moduleReference = {
-					path: modulePath,
-					name: ModuleConfigUtil.readModuleNameSync(modulePath)
-				};
-			} else if (ModuleReferenceConfigHelp.isInlineModuleReference(moduleReferenceConfig)) {
-				const modulePath = path.join(configDir, moduleReferenceConfig.path);
-				moduleReference = {
-					path: modulePath,
-					name: ModuleConfigUtil.readModuleNameSync(modulePath)
-				};
-			} else throw new Error("unknown type of module reference config: " + JSON.stringify(moduleReferenceConfig));
-			moduleReferenceList.push(moduleReference);
-		}
-		return moduleReferenceList;
-	}
-	static readModuleReferenceFromScan(baseDir, options) {
-		const ref = [];
-		const realOptions = Object.assign({}, DEFAULT_READ_MODULE_REF_OPTS, options);
-		const packagePaths = globbySync([
-			"**/package.json",
-			"!**/node_modules",
-			"!**/+(.*)/**",
-			"!**/coverage",
-			...realOptions.extraFilePattern || []
-		], {
-			cwd: baseDir,
-			deep: realOptions.deep
-		});
-		const moduleDirSet = /* @__PURE__ */ new Set();
-		for (const packagePath of packagePaths) {
-			const absolutePkgPath = path.join(baseDir, packagePath);
-			let realPkgPath;
-			try {
-				realPkgPath = fs.realpathSync(absolutePkgPath);
-			} catch {
-				continue;
-			}
-			const moduleDir = path.dirname(realPkgPath);
-			if (moduleDirSet.has(moduleDir)) continue;
-			moduleDirSet.add(moduleDir);
-			let name;
-			try {
-				name = this.readModuleNameSync(moduleDir);
-			} catch {
-				continue;
-			}
-			ref.push({
-				path: moduleDir,
-				name
-			});
-		}
-		const moduleReferences = this.readModuleFromNodeModules(baseDir);
-		for (const moduleReference of moduleReferences) {
-			const moduleBasePath = path.basename(moduleReference.path);
-			moduleDirSet.forEach((modulePath) => {
-				if (path.basename(modulePath) === moduleBasePath) throw new Error("duplicate import of module reference: " + moduleBasePath);
-			});
-			ref.push({
-				path: moduleReference.path,
-				name: moduleReference.name
-			});
-		}
-		return ref;
-	}
-	static readModuleFromNodeModules(baseDir) {
-		const ref = [];
-		let pkgContent;
-		try {
-			pkgContent = fs.readFileSync(path.join(baseDir, "package.json"), "utf8");
-		} catch {
-			return [];
-		}
-		const pkg = JSON.parse(pkgContent);
-		for (const dependencyKey of Object.keys(pkg.dependencies || {})) {
-			let packageJsonPath;
-			try {
-				packageJsonPath = importResolve(`${dependencyKey}/package.json`, { paths: [baseDir] });
-			} catch {
-				continue;
-			}
-			const absolutePkgPath = path.dirname(packageJsonPath);
-			const realPkgPath = fs.realpathSync(absolutePkgPath);
-			try {
-				const name = this.readModuleNameSync(realPkgPath);
-				ref.push({
-					path: realPkgPath,
-					name
-				});
-			} catch {
-				continue;
-			}
-		}
-		return ref;
-	}
-	static resolveModuleDir(moduleDir, baseDir) {
-		if (path.isAbsolute(moduleDir)) return moduleDir;
-		assert(baseDir, "baseDir is required");
-		return path.join(baseDir, "config", moduleDir);
-	}
-	static getModuleName(pkg) {
-		assert(pkg.eggModule && pkg.eggModule.name, "eggModule.name not found in package.json");
-		return pkg.eggModule.name;
-	}
-	static async readModuleName(baseDir, moduleDir) {
-		moduleDir = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
-		const pkgContent = await promises.readFile(path.join(moduleDir, "package.json"), "utf8");
-		const pkg = JSON.parse(pkgContent);
-		return ModuleConfigUtil.getModuleName(pkg);
-	}
-	static readModuleNameSync(moduleDir, baseDir) {
-		moduleDir = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
-		const pkgContent = fs.readFileSync(path.join(moduleDir, "package.json"), "utf8");
-		const pkg = JSON.parse(pkgContent);
-		return ModuleConfigUtil.getModuleName(pkg);
-	}
-	static async loadModuleConfig(moduleDir, baseDir, env) {
-		const modulePath = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
-		let configNames;
-		if (env) configNames = ["module", `module.${env}`];
-		else configNames = ModuleConfigUtil.configNames || ["module"];
-		const target = {};
-		for (const configName of configNames) {
-			let config = await ModuleConfigUtil.#loadOne(modulePath, configName);
-			if (configName === "module.default" && !config) config = await ModuleConfigUtil.#loadOne(modulePath, "module");
-			if (config) extend(true, target, config);
-		}
-		return target;
-	}
-	static async #loadOne(moduleDir, configName) {
-		const yamlConfigPath = path.join(moduleDir, `${configName}.yml`);
-		let config = await ModuleConfigUtil.#loadYaml(yamlConfigPath);
-		if (!config) {
-			const jsonConfigPath = path.join(moduleDir, `${configName}.json`);
-			config = await ModuleConfigUtil.#loadJson(jsonConfigPath);
-		}
-		return config;
-	}
-	static async #loadJson(moduleJsonPath) {
-		if (!await FSUtil.fileExists(moduleJsonPath)) return;
-		const moduleJsonContent = await promises.readFile(moduleJsonPath, "utf8");
-		return JSON.parse(moduleJsonContent).config;
-	}
-	static async #loadYaml(moduleYamlPath) {
-		if (!await FSUtil.fileExists(moduleYamlPath)) return;
-		const moduleYamlContent = await promises.readFile(moduleYamlPath, "utf8");
-		return load(moduleYamlContent);
-	}
-	static loadModuleConfigSync(moduleDir, baseDir, env) {
-		const modulePath = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
-		let configNames;
-		if (env) configNames = ["module", `module.${env}`];
-		else configNames = ModuleConfigUtil.configNames || ["module"];
-		const target = {};
-		for (const configName of configNames) {
-			let config = ModuleConfigUtil.#loadOneSync(modulePath, configName);
-			if (configName === "module.default" && !config) config = ModuleConfigUtil.#loadOneSync(modulePath, "module");
-			if (config) extend(true, target, config);
-		}
-		return target;
-	}
-	static #loadOneSync(moduleDir, configName) {
-		const yamlConfigPath = path.join(moduleDir, `${configName}.yml`);
-		let config = ModuleConfigUtil.#loadYamlSync(yamlConfigPath);
-		if (!config) {
-			const jsonConfigPath = path.join(moduleDir, `${configName}.json`);
-			config = ModuleConfigUtil.#loadJsonSync(jsonConfigPath);
-		}
-		return config;
-	}
-	static #loadJsonSync(moduleJsonPath) {
-		if (!fs.existsSync(moduleJsonPath)) return;
-		const moduleJsonContent = fs.readFileSync(moduleJsonPath, "utf8");
-		return JSON.parse(moduleJsonContent).config;
-	}
-	static #loadYamlSync(moduleYamlPath) {
-		if (!fs.existsSync(moduleYamlPath)) return;
-		const moduleYamlContent = fs.readFileSync(moduleYamlPath, "utf8");
-		return load(moduleYamlContent);
-	}
-};
-
-//#endregion
-export { ModuleConfigUtil, ModuleReferenceConfigHelp };

package/dist/ModuleConfigs.d.ts

@@ -1,10 +0,0 @@
-import { ModuleConfig as ModuleConfig$1, ModuleConfigHolder } from "@eggjs/tegg-types";
-
-//#region src/ModuleConfigs.d.ts
-declare class ModuleConfigs {
-  readonly inner: Record<string, ModuleConfigHolder>;
-  constructor(inner: Record<string, ModuleConfigHolder>);
-  get(moduleName: string): ModuleConfig$1 | undefined;
-}
-//#endregion
-export { type ModuleConfig$1 as ModuleConfig, ModuleConfigs };

package/dist/ModuleConfigs.js

@@ -1,13 +0,0 @@
-//#region src/ModuleConfigs.ts
-var ModuleConfigs = class {
-	inner;
-	constructor(inner) {
-		this.inner = inner;
-	}
-	get(moduleName) {
-		return this.inner[moduleName]?.config;
-	}
-};
-
-//#endregion
-export { ModuleConfigs };

package/dist/NameUtil.d.ts

@@ -1,6 +0,0 @@
-//#region src/NameUtil.d.ts
-declare class NameUtil {
-  static getClassName(constructor: Function): string;
-}
-//#endregion
-export { NameUtil };

package/dist/NameUtil.js

@@ -1,9 +0,0 @@
-//#region src/NameUtil.ts
-var NameUtil = class {
-	static getClassName(constructor) {
-		return constructor.name[0].toLowerCase() + constructor.name.substring(1);
-	}
-};
-
-//#endregion
-export { NameUtil };

package/dist/ObjectUtils.d.ts

@@ -1,10 +0,0 @@
-import { EggProtoImplClass } from "@eggjs/tegg-types";
-
-//#region src/ObjectUtils.d.ts
-declare class ObjectUtils {
-  static getProperties(obj: object): string[];
-  static getFunctionArgNameList(func: Function): string[];
-  static getConstructorArgNameList(clazz: EggProtoImplClass): string[];
-}
-//#endregion
-export { ObjectUtils };

package/dist/ObjectUtils.js

@@ -1,29 +0,0 @@
-//#region src/ObjectUtils.ts
-var ObjectUtils = class {
-	static getProperties(obj) {
-		const properties = [];
-		do
-			for (const property of Object.getOwnPropertyNames(obj)) properties.push(property);
-		while ((obj = Object.getPrototypeOf(obj)) && obj !== Object.prototype);
-		return properties;
-	}
-	static getFunctionArgNameList(func) {
-		if (func.length === 0) return [];
-		let sourcecode = func.toString();
-		sourcecode = sourcecode.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/(.)*/g, "").replace(/{[\s\S]*}/, "").replace(/=>/g, "").trim();
-		let argsString = sourcecode.substring(sourcecode.indexOf("(") + 1, sourcecode.length - 1);
-		argsString = argsString.replace(/=\([\s\S]*\)/g, "");
-		return argsString.split(",").map((arg) => {
-			return arg.replace(/=[\s\S]*/g, "").trim();
-		}).filter((arg) => arg.length);
-	}
-	static getConstructorArgNameList(clazz) {
-		if (clazz.length === 0) return [];
-		const constructorMatch = clazz.toString().match(/constructor\s*\(([^)]+)\)/);
-		if (!constructorMatch) return [];
-		return constructorMatch[1].split(",").map((param) => param.trim()).map((param) => param.match(/(\w+)\s*(?=\s*(?:=|\/\/|\s*$))/)).filter(Boolean).map((match) => match[0].trim());
-	}
-};
-
-//#endregion
-export { ObjectUtils };

package/dist/ProxyUtil.d.ts

@@ -1,6 +0,0 @@
-//#region src/ProxyUtil.d.ts
-declare class ProxyUtil {
-  static safeProxy<T extends object>(obj: T, getter: (obj: T, p: PropertyKey) => any): T;
-}
-//#endregion
-export { ProxyUtil };

package/dist/ProxyUtil.js

@@ -1,12 +0,0 @@
-//#region src/ProxyUtil.ts
-var ProxyUtil = class {
-	static safeProxy(obj, getter) {
-		return new Proxy(obj, { get(target, p) {
-			if (Object.prototype[p]) return Reflect.get(target, p);
-			return getter(target, p);
-		} });
-	}
-};
-
-//#endregion
-export { ProxyUtil };

package/dist/StackUtil.d.ts

@@ -1,6 +0,0 @@
-//#region src/StackUtil.d.ts
-declare class StackUtil {
-  static getCalleeFromStack(withLine: boolean, stackIndex?: number): string;
-}
-//#endregion
-export { StackUtil };

package/dist/StackUtil.js

@@ -1,39 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { debuglog } from "node:util";
-
-//#region src/StackUtil.ts
-const debug = debuglog("@eggjs/tegg-common-util/StackUtil");
-/**
-* Capture call site stack from v8.
-* https://github.com/v8/v8/wiki/Stack-Trace-API
-*/
-function prepareObjectStackTrace(_, stack) {
-	return stack;
-}
-var StackUtil = class {
-	static getCalleeFromStack(withLine, stackIndex) {
-		stackIndex = stackIndex === void 0 ? 2 : stackIndex;
-		const limit = Error.stackTraceLimit;
-		const prep = Error.prepareStackTrace;
-		Error.prepareStackTrace = prepareObjectStackTrace;
-		Error.stackTraceLimit = 10;
-		const obj = { stack: [] };
-		Error.captureStackTrace(obj);
-		if (debug.enabled) debug("call stack: %o", obj.stack.map((callSite$1) => callSite$1.getFileName() ?? "<anonymous>").join("\n"));
-		const callSite = obj.stack[stackIndex];
-		let fileName;
-		if (callSite) {
-			fileName = callSite.getFileName();
-			if (fileName?.startsWith("file://")) fileName = fileURLToPath(fileName);
-		}
-		Error.prepareStackTrace = prep;
-		Error.stackTraceLimit = limit;
-		/* istanbul ignore if */
-		if (!callSite || !fileName) return "<anonymous>";
-		if (!withLine) return fileName;
-		return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
-	}
-};
-
-//#endregion
-export { StackUtil };

package/dist/TimerUtil.d.ts

@@ -1,6 +0,0 @@
-//#region src/TimerUtil.d.ts
-declare class TimerUtil {
-  static sleep(ms: number): Promise<void>;
-}
-//#endregion
-export { TimerUtil };

package/dist/TimerUtil.js

@@ -1,9 +0,0 @@
-//#region src/TimerUtil.ts
-var TimerUtil = class {
-	static async sleep(ms) {
-		await new Promise((resolve) => setTimeout(resolve, ms));
-	}
-};
-
-//#endregion
-export { TimerUtil };