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

package/dist/FSUtil.d.ts

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

package/dist/FSUtil.js

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

package/dist/Graph.d.ts

@@ -0,0 +1,46 @@
+import { GraphNodeObj } from "@eggjs/tegg-types";
+
+//#region src/Graph.d.ts
+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;
+  toJSON(): object;
+  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;
+}
+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

@@ -0,0 +1,121 @@
+//#region src/Graph.ts
+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;
+	}
+	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("");
+	}
+};
+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) {
+		if (accessed[nodes.indexOf(node)]) 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

@@ -0,0 +1,6 @@
+//#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

@@ -0,0 +1,10 @@
+//#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

@@ -0,0 +1,30 @@
+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;
+  /**
+  * Deduplicate module references to avoid adding the same module multiple times.
+  * @param moduleReferences array of module references
+  * @return deduplicated module references
+  */
+  static deduplicateModules(moduleReferences: readonly ModuleReference[]): readonly ModuleReference[];
+}
+//#endregion
+export { ModuleConfigUtil, ModuleReferenceConfigHelp };

package/dist/ModuleConfig.js

@@ -0,0 +1,259 @@
+import { FSUtil } from "./FSUtil.js";
+import assert from "node:assert";
+import fs, { promises } from "node:fs";
+import path from "node:path";
+import { importResolve } from "@eggjs/utils";
+import { extend } from "extend2";
+import globby from "globby";
+import { load } from "js-yaml";
+
+//#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 file = importResolve(path.posix.join(moduleReferenceConfig.package, "package.json"), 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 = globby.sync([
+			"**/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;
+		return load(await promises.readFile(moduleYamlPath, "utf8"));
+	}
+	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;
+		return load(fs.readFileSync(moduleYamlPath, "utf8"));
+	}
+	/**
+	* Deduplicate module references to avoid adding the same module multiple times.
+	* @param moduleReferences array of module references
+	* @return deduplicated module references
+	*/
+	static deduplicateModules(moduleReferences) {
+		const moduleMap = /* @__PURE__ */ new Map();
+		const nameMap = /* @__PURE__ */ new Map();
+		for (const moduleRef of moduleReferences) {
+			const key = moduleRef.path;
+			const existingRef = moduleMap.get(key);
+			if (existingRef) {
+				const existingOptional = existingRef.optional ?? false;
+				const currentOptional = moduleRef.optional ?? false;
+				if (!existingOptional && currentOptional) continue;
+				else if (existingOptional && !currentOptional) {
+					if (existingRef.name !== moduleRef.name) {
+						const existingByName$1 = nameMap.get(moduleRef.name);
+						if (existingByName$1) throw new Error(`Duplicate module name "${moduleRef.name}" found: existing at ${existingByName$1.path}, duplicate at ${moduleRef.path}`);
+					}
+					const newModuleRef = {
+						...moduleRef,
+						optional: false
+					};
+					moduleMap.set(key, newModuleRef);
+					if (nameMap.get(existingRef.name) === existingRef) nameMap.delete(existingRef.name);
+					nameMap.set(newModuleRef.name, newModuleRef);
+					continue;
+				}
+				continue;
+			}
+			const existingByName = nameMap.get(moduleRef.name);
+			if (existingByName) throw new Error(`Duplicate module name "${moduleRef.name}" found: existing at ${existingByName.path}, duplicate at ${moduleRef.path}`);
+			moduleMap.set(key, moduleRef);
+			nameMap.set(moduleRef.name, moduleRef);
+		}
+		return Array.from(moduleMap.values());
+	}
+};
+
+//#endregion
+export { ModuleConfigUtil, ModuleReferenceConfigHelp };

package/dist/ModuleConfigs.d.ts

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

@@ -0,0 +1,13 @@
+//#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

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

package/dist/NameUtil.js

@@ -0,0 +1,9 @@
+//#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

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

@@ -0,0 +1,29 @@
+//#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

@@ -0,0 +1,6 @@
+//#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

@@ -0,0 +1,12 @@
+//#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

@@ -0,0 +1,12 @@
+//#region src/StackUtil.d.ts
+declare class StackUtil {
+  /**
+  * Get the callee file path from the stack.
+  * @param withLine - Whether to include the line number and column number in the result. Default is false.
+  * @param stackIndex - The index of the stack frame to get. Default is 2.
+  * @returns The callee file path from the stack.
+  */
+  static getCalleeFromStack(withLine?: boolean, stackIndex?: number): string;
+}
+//#endregion
+export { StackUtil };