@eggjs/utils 5.0.0-beta.19 → 5.0.0-beta.20

package/dist/index.d.ts

@@ -1,11 +1,104 @@
-import { getFrameworkPath } from "./framework.js";
-import { findEggCore, getConfig, getLoadUnits, getLoader, getPlugins } from "./plugin.js";
-import { getFrameworkOrEggPath } from "./deprecated.js";
-import { ImportModuleOptions, ImportResolveOptions, getExtensions, getRequire, importModule, importResolve, isESM, isSupportTypeScript } from "./import.js";
-import { ImportResolveError } from "./error/ImportResolveError.js";
-
+//#region src/framework.d.ts
+interface Options {
+  baseDir: string;
+  framework?: string;
+}
+/**
+ * Find the framework directory, lookup order
+ * - specify framework path
+ * - get framework name from
+ * - use egg by default
+ * @param {Object} options - options
+ * @param  {String} options.baseDir - the current directory of application
+ * @param  {String} [options.framework] - the directory of framework
+ * @return {String} frameworkPath
+ */
+declare function getFrameworkPath(options: Options): string;
+//#endregion
+//#region src/plugin.d.ts
+interface LoaderOptions {
+  framework: string;
+  baseDir: string;
+  env?: string;
+}
+interface Plugin {
+  name: string;
+  version?: string;
+  enable: boolean;
+  implicitEnable: boolean;
+  path: string;
+  dependencies: string[];
+  optionalDependencies: string[];
+  env: string[];
+  from: string;
+}
+/**
+ * @see https://github.com/eggjs/egg-core/blob/2920f6eade07959d25f5c4f96b154d3fbae877db/lib/loader/mixin/plugin.js#L203
+ */
+declare function getPlugins(options: LoaderOptions): Promise<Record<string, Plugin>>;
+interface Unit {
+  type: 'plugin' | 'framework' | 'app';
+  path: string;
+}
+/**
+ * @see https://github.com/eggjs/egg-core/blob/2920f6eade07959d25f5c4f96b154d3fbae877db/lib/loader/egg_loader.js#L348
+ */
+declare function getLoadUnits(options: LoaderOptions): Promise<Unit[]>;
+declare function getConfig(options: LoaderOptions): Promise<Record<string, any>>;
+interface IEggLoader {
+  loadPlugin(): Promise<void>;
+  loadConfig(): Promise<void>;
+  config: Record<string, any>;
+  getLoadUnits(): Unit[];
+  allPlugins: Record<string, Plugin>;
+}
+interface IEggLoaderOptions {
+  baseDir: string;
+  app: unknown;
+  logger: object;
+  EggCoreClass?: unknown;
+}
+type EggLoaderImplClass<T = IEggLoader> = new (options: IEggLoaderOptions) => T;
+declare function getLoader(options: LoaderOptions): Promise<IEggLoader>;
+declare function findEggCore(options: LoaderOptions): Promise<{
+  EggCore?: object;
+  EggLoader: EggLoaderImplClass;
+}>;
+//#endregion
+//#region src/deprecated.d.ts
+/**
+ * Try to get framework dir path
+ * If can't find any framework, try to find egg dir path
+ *
+ * @param {String} cwd - current work path
+ * @param {Array} [eggNames] - egg names, default is ['egg']
+ * @return {String} framework or egg dir path
+ * @deprecated
+ */
+declare function getFrameworkOrEggPath(cwd: string, eggNames?: string[]): string;
+//#endregion
+//#region src/import.d.ts
+interface ImportResolveOptions {
+  paths?: string[];
+}
+interface ImportModuleOptions extends ImportResolveOptions {
+  importDefaultOnly?: boolean;
+}
+declare let isESM: boolean;
+declare function getRequire(): NodeRequire;
+declare function getExtensions(): NodeJS.RequireExtensions;
+declare function isSupportTypeScript(): boolean;
+declare function importResolve(filepath: string, options?: ImportResolveOptions): string;
+declare function importModule(filepath: string, options?: ImportModuleOptions): Promise<any>;
+//#endregion
+//#region src/error/ImportResolveError.d.ts
+declare class ImportResolveError extends Error {
+  filepath: string;
+  paths: string[];
+  constructor(filepath: string, paths: string[], error: Error);
+}
+//#endregion
 //#region src/index.d.ts
-
 declare const _default: {
   getFrameworkPath: typeof getFrameworkPath;
   getPlugins: typeof getPlugins;

package/dist/index.js

@@ -1,11 +1,452 @@
-import { ImportResolveError } from "./error/ImportResolveError.js";
-import { getExtensions, getRequire, importModule, importResolve, isESM, isSupportTypeScript } from "./import.js";
-import { getFrameworkPath } from "./framework.js";
-import { findEggCore, getConfig, getLoadUnits, getLoader, getPlugins } from "./plugin.js";
-import { getFrameworkOrEggPath } from "./deprecated.js";
+import { createRequire } from "node:module";
 import path from "node:path";
-import fs from "node:fs/promises";
+import fs, { mkdir, realpath, stat, writeFile } from "node:fs/promises";
+import { debuglog } from "node:util";
+import assert from "node:assert";
+import fs$1, { existsSync, readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import os from "node:os";
 
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/utils.ts
+function readJSONSync(file) {
+	if (!existsSync(file)) throw new Error(`${file} is not found`);
+	return JSON.parse(readFileSync(file, "utf-8"));
+}
+
+//#endregion
+//#region src/error/ImportResolveError.ts
+var ImportResolveError = class extends Error {
+	filepath;
+	paths;
+	constructor(filepath, paths, error) {
+		const message = `${error.message}, paths: ${JSON.stringify(paths)}`;
+		super(message, { cause: error });
+		this.name = this.constructor.name;
+		this.filepath = filepath;
+		this.paths = paths;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+
+//#endregion
+//#region src/import.ts
+const debug$2 = debuglog("egg/utils/import");
+let isESM = true;
+try {
+	if (typeof import.meta !== "undefined") isESM = true;
+} catch {
+	isESM = false;
+}
+const supportImportMetaResolve = parseInt(process.versions.node.split(".", 1)[0], 10) >= 18;
+let _customRequire;
+function getRequire() {
+	if (!_customRequire) if (typeof __require !== "undefined") _customRequire = __require;
+	else _customRequire = createRequire(process.cwd());
+	return _customRequire;
+}
+function getExtensions() {
+	return getRequire().extensions;
+}
+let _supportTypeScript;
+function isSupportTypeScript() {
+	if (_supportTypeScript === void 0) {
+		const extensions = getExtensions();
+		_supportTypeScript = extensions[".ts"] !== void 0 || process.env.VITEST === "true" || process.env.EGG_TS_ENABLE === "true" || parseInt(process.versions.node.split(".", 1)[0], 10) >= 22;
+		debug$2("[isSupportTypeScript] %o, extensions: %j, process.env.VITEST: %j, process.env.EGG_TS_ENABLE: %j, node version: %s", _supportTypeScript, Object.keys(extensions), process.env.VITEST, process.env.EGG_TS_ENABLE, process.versions.node);
+	}
+	return _supportTypeScript;
+}
+function tryToResolveFromFile(filepath) {
+	const type = isESM ? "module" : "commonjs";
+	let mainIndexFile = "";
+	if (type === "module") {
+		mainIndexFile = filepath + ".mjs";
+		if (fs$1.existsSync(mainIndexFile)) {
+			debug$2("[tryToResolveFromFile] %o, use index.mjs, type: %o", mainIndexFile, type);
+			return mainIndexFile;
+		}
+		mainIndexFile = filepath + ".js";
+		if (fs$1.existsSync(mainIndexFile)) {
+			debug$2("[tryToResolveFromFile] %o, use index.js, type: %o", mainIndexFile, type);
+			return mainIndexFile;
+		}
+	} else {
+		mainIndexFile = filepath + ".cjs";
+		if (fs$1.existsSync(mainIndexFile)) {
+			debug$2("[tryToResolveFromFile] %o, use index.cjs, type: %o", mainIndexFile, type);
+			return mainIndexFile;
+		}
+		mainIndexFile = filepath + ".js";
+		if (fs$1.existsSync(mainIndexFile)) {
+			debug$2("[tryToResolveFromFile] %o, use index.js, type: %o", mainIndexFile, type);
+			return mainIndexFile;
+		}
+	}
+	if (!isSupportTypeScript()) return;
+	mainIndexFile = filepath + ".ts";
+	if (fs$1.existsSync(mainIndexFile)) {
+		debug$2("[tryToResolveFromFile] %o, use index.ts, type: %o", mainIndexFile, type);
+		return mainIndexFile;
+	}
+}
+function tryToResolveByDirnameFromPackage(dirname, pkg) {
+	const defaultMainFile = isESM ? pkg.module ?? pkg.main : pkg.main;
+	if (defaultMainFile) {
+		const mainIndexFilePath$1 = path.join(dirname, defaultMainFile);
+		if (fs$1.existsSync(mainIndexFilePath$1)) {
+			debug$2("[tryToResolveByDirnameFromPackage] %o, use pkg.main or pkg.module: %o, isESM: %s", mainIndexFilePath$1, defaultMainFile, isESM);
+			return mainIndexFilePath$1;
+		}
+	}
+	if (pkg.exports?.["."]) {
+		const pkgType = pkg.type ?? "commonjs";
+		const defaultExport = pkg.exports["."];
+		let mainIndexFilePath$1 = "";
+		if (typeof defaultExport === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport);
+		else if (pkgType === "module") {
+			if (typeof defaultExport.import === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport.import);
+			else if (typeof defaultExport.import?.default === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport.import.default);
+		} else if (typeof defaultExport.require === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport.require);
+		else if (typeof defaultExport.require?.default === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport.require.default);
+		if (mainIndexFilePath$1 && fs$1.existsSync(mainIndexFilePath$1)) {
+			debug$2("[tryToResolveByDirnameFromPackage] %o, use pkg.exports[.]: %o, pkg.type: %o", mainIndexFilePath$1, defaultExport, pkgType);
+			return mainIndexFilePath$1;
+		}
+	}
+	const type = pkg?.type ?? (isESM ? "module" : "commonjs");
+	if (type === "module") {
+		const mainIndexFilePath$1 = path.join(dirname, "index.mjs");
+		if (fs$1.existsSync(mainIndexFilePath$1)) {
+			debug$2("[tryToResolveByDirnameFromPackage] %o, use index.mjs, pkg.type: %o", mainIndexFilePath$1, type);
+			return mainIndexFilePath$1;
+		}
+		const mainIndexMjsFilePath = path.join(dirname, "index.js");
+		if (fs$1.existsSync(mainIndexMjsFilePath)) {
+			debug$2("[tryToResolveByDirnameFromPackage] %o, use index.js, pkg.type: %o", mainIndexMjsFilePath, type);
+			return mainIndexMjsFilePath;
+		}
+	} else {
+		const mainIndexFilePath$1 = path.join(dirname, "index.cjs");
+		if (fs$1.existsSync(mainIndexFilePath$1)) {
+			debug$2("[tryToResolveByDirnameFromPackage] %o, use index.cjs, pkg.type: %o", mainIndexFilePath$1, type);
+			return mainIndexFilePath$1;
+		}
+		const mainIndexCjsFilePath = path.join(dirname, "index.js");
+		if (fs$1.existsSync(mainIndexCjsFilePath)) {
+			debug$2("[tryToResolveByDirnameFromPackage] %o, use index.js, pkg.type: %o", mainIndexCjsFilePath, type);
+			return mainIndexCjsFilePath;
+		}
+	}
+	if (!isSupportTypeScript()) return;
+	const mainIndexFile = pkg.tshy?.exports?.["."] ?? "index.ts";
+	const mainIndexFilePath = path.join(dirname, mainIndexFile);
+	if (fs$1.existsSync(mainIndexFilePath)) return mainIndexFilePath;
+}
+function tryToResolveByDirname(dirname) {
+	let pkg = {};
+	const pkgFile = path.join(dirname, "package.json");
+	if (fs$1.existsSync(pkgFile)) pkg = JSON.parse(fs$1.readFileSync(pkgFile, "utf-8"));
+	return tryToResolveByDirnameFromPackage(dirname, pkg);
+}
+function isRelativePath(filepath) {
+	return filepath.startsWith("./") || filepath.startsWith("../") || filepath.startsWith(".\\") || filepath.startsWith("..\\");
+}
+function tryToResolveFromAbsoluteFile(filepath) {
+	let moduleFilePath;
+	const stat$1 = fs$1.statSync(filepath, { throwIfNoEntry: false });
+	if (stat$1?.isDirectory()) {
+		moduleFilePath = tryToResolveByDirname(filepath);
+		if (moduleFilePath) return moduleFilePath;
+	} else if (stat$1?.isFile()) return filepath;
+	moduleFilePath = tryToResolveFromFile(filepath);
+	if (moduleFilePath) return moduleFilePath;
+	const parentDir = path.dirname(filepath);
+	const basename = path.basename(filepath);
+	const pkgFile = path.join(parentDir, "package.json");
+	if (fs$1.existsSync(pkgFile)) {
+		const pkg = JSON.parse(fs$1.readFileSync(pkgFile, "utf-8"));
+		const key = `./${basename}`;
+		if (pkg.exports?.[key]) return path.join(parentDir, pkg.exports[key]);
+	}
+}
+function importResolve(filepath, options) {
+	const paths = options?.paths ?? [process.cwd()];
+	debug$2("[importResolve] filepath: %o, options: %j, paths: %j", filepath, options, paths);
+	let moduleFilePath;
+	const isAbsolute = path.isAbsolute(filepath);
+	if (isAbsolute) {
+		moduleFilePath = tryToResolveFromAbsoluteFile(filepath);
+		if (moduleFilePath) {
+			debug$2("[importResolve:isAbsolute] %o => %o", filepath, moduleFilePath);
+			return moduleFilePath;
+		}
+	} else if (isRelativePath(filepath)) for (const p of paths) {
+		const resolvedPath = path.resolve(p, filepath);
+		moduleFilePath = tryToResolveFromAbsoluteFile(resolvedPath);
+		if (moduleFilePath) {
+			debug$2("[importResolve:isRelativePath] %o => %o => %o", filepath, resolvedPath, moduleFilePath);
+			return moduleFilePath;
+		}
+	}
+	for (const p of paths) {
+		let resolvedPath = path.join(p, "node_modules", filepath);
+		moduleFilePath = tryToResolveFromAbsoluteFile(resolvedPath);
+		if (moduleFilePath) {
+			debug$2("[importResolve:node_modules] %o => %o => %o", filepath, resolvedPath, moduleFilePath);
+			return moduleFilePath;
+		}
+		let parentPath = path.dirname(p);
+		if (path.basename(parentPath) === "node_modules") {
+			resolvedPath = path.join(parentPath, filepath);
+			moduleFilePath = tryToResolveFromAbsoluteFile(resolvedPath);
+			if (moduleFilePath) {
+				debug$2("[importResolve:node_modules] %o => %o => %o", filepath, resolvedPath, moduleFilePath);
+				return moduleFilePath;
+			}
+		}
+		parentPath = path.dirname(parentPath);
+		if (path.basename(parentPath) === "node_modules") {
+			resolvedPath = path.join(parentPath, filepath);
+			moduleFilePath = tryToResolveFromAbsoluteFile(resolvedPath);
+			if (moduleFilePath) {
+				debug$2("[importResolve:node_modules] %o => %o => %o", filepath, resolvedPath, moduleFilePath);
+				return moduleFilePath;
+			}
+		}
+	}
+	const extname = path.extname(filepath);
+	if (!isAbsolute && extname === ".json" || !isESM) moduleFilePath = getRequire().resolve(filepath, { paths });
+	else if (supportImportMetaResolve) {
+		try {
+			moduleFilePath = import.meta.resolve(filepath);
+		} catch (err) {
+			debug$2("[importResolve:error] import.meta.resolve %o => %o, options: %o", filepath, err, options);
+			throw new ImportResolveError(filepath, paths, err);
+		}
+		if (moduleFilePath.startsWith("file://")) moduleFilePath = fileURLToPath(moduleFilePath);
+		debug$2("[importResolve] import.meta.resolve %o => %o", filepath, moduleFilePath);
+		if (!fs$1.statSync(moduleFilePath, { throwIfNoEntry: false })?.isFile()) throw new TypeError(`Cannot find module ${filepath}, because ${moduleFilePath} does not exists`);
+	} else moduleFilePath = getRequire().resolve(filepath);
+	debug$2("[importResolve:success] %o, options: %o => %o, isESM: %s", filepath, options, moduleFilePath, isESM);
+	return moduleFilePath;
+}
+async function importModule(filepath, options) {
+	const moduleFilePath = importResolve(filepath, options);
+	let obj;
+	if (isESM) {
+		const fileUrl = pathToFileURL(moduleFilePath).toString();
+		obj = await import(fileUrl);
+		debug$2("[importModule:success] await import %o", fileUrl);
+		if (obj?.default?.__esModule === true && "default" in obj?.default) obj = obj.default;
+		if (options?.importDefaultOnly) {
+			if ("default" in obj) obj = obj.default;
+		}
+	} else {
+		obj = __require(moduleFilePath);
+		debug$2("[importModule] require %o", moduleFilePath);
+		if (obj?.__esModule === true && "default" in obj) obj = obj.default;
+	}
+	if (debug$2.enabled) debug$2("[importModule] return %o => keys: %j, typeof obj: %s", filepath, obj ? Object.keys(obj) : obj, typeof obj);
+	return obj;
+}
+
+//#endregion
+//#region src/framework.ts
+const debug$1 = debuglog("egg/utils/framework");
+const initCwd = process.cwd();
+/**
+* Find the framework directory, lookup order
+* - specify framework path
+* - get framework name from
+* - use egg by default
+* @param {Object} options - options
+* @param  {String} options.baseDir - the current directory of application
+* @param  {String} [options.framework] - the directory of framework
+* @return {String} frameworkPath
+*/
+function getFrameworkPath(options) {
+	const { framework, baseDir } = options;
+	const pkgPath = path.join(baseDir, "package.json");
+	assert(existsSync(pkgPath), `${pkgPath} should exist`);
+	const moduleDir = path.join(baseDir, "node_modules");
+	if (framework) {
+		if (path.isAbsolute(framework)) {
+			assert(existsSync(framework), `${framework} should exist`);
+			return framework;
+		}
+		return assertAndReturn(framework, moduleDir, baseDir);
+	}
+	const pkg = readJSONSync(pkgPath);
+	if (pkg.egg?.framework) return assertAndReturn(pkg.egg.framework, moduleDir, baseDir);
+	return assertAndReturn("egg", moduleDir, baseDir);
+}
+function assertAndReturn(frameworkName, moduleDir, baseDir) {
+	const moduleDirs = new Set([
+		moduleDir,
+		path.join(process.cwd(), "node_modules"),
+		path.join(initCwd, "node_modules")
+	]);
+	try {
+		let globalModuleDir;
+		if (frameworkName.startsWith("@") && frameworkName.includes("/")) globalModuleDir = path.join(importResolve(`${frameworkName}/package.json`, { paths: [baseDir] }), "../../..");
+		else globalModuleDir = path.join(importResolve(`${frameworkName}/package.json`, { paths: [baseDir] }), "../..");
+		moduleDirs.add(globalModuleDir);
+	} catch {}
+	for (const moduleDir$1 of moduleDirs) {
+		const frameworkPath = path.join(moduleDir$1, frameworkName);
+		if (existsSync(frameworkPath)) {
+			debug$1("[assertAndReturn] frameworkPath: %s, moduleDirs: %o", frameworkPath, moduleDirs);
+			return frameworkPath;
+		}
+	}
+	throw new Error(`${frameworkName} is not found in ${Array.from(moduleDirs)}`);
+}
+
+//#endregion
+//#region src/plugin.ts
+const debug = debuglog("egg/utils/plugin");
+const tmpDir = os.tmpdir();
+function noop() {}
+const logger = {
+	debug: noop,
+	info: noop,
+	warn: noop,
+	error: noop
+};
+/**
+* @see https://github.com/eggjs/egg-core/blob/2920f6eade07959d25f5c4f96b154d3fbae877db/lib/loader/mixin/plugin.js#L203
+*/
+async function getPlugins(options) {
+	const loader = await getLoader(options);
+	await loader.loadPlugin();
+	return loader.allPlugins;
+}
+/**
+* @see https://github.com/eggjs/egg-core/blob/2920f6eade07959d25f5c4f96b154d3fbae877db/lib/loader/egg_loader.js#L348
+*/
+async function getLoadUnits(options) {
+	const loader = await getLoader(options);
+	await loader.loadPlugin();
+	return loader.getLoadUnits();
+}
+async function getConfig(options) {
+	const loader = await getLoader(options);
+	await loader.loadPlugin();
+	await loader.loadConfig();
+	return loader.config;
+}
+async function exists(filepath) {
+	try {
+		await stat(filepath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function getLoader(options) {
+	assert(options.framework, "framework is required");
+	assert(await exists(options.framework), `${options.framework} should exist`);
+	if (!(options.baseDir && await exists(options.baseDir))) {
+		options.baseDir = path.join(tmpDir, "egg_utils", `${Date.now()}`, "tmp_app");
+		await mkdir(options.baseDir, { recursive: true });
+		await writeFile(path.join(options.baseDir, "package.json"), JSON.stringify({
+			name: "tmp_app",
+			type: "module"
+		}));
+		debug("[getLoader] create baseDir: %o", options.baseDir);
+	}
+	const { EggCore, EggLoader } = await findEggCore(options);
+	const mod = await importModule(options.framework);
+	const Application = mod.Application ?? mod.default?.Application;
+	assert(Application, `Application not export on ${options.framework}`);
+	if (options.env) process.env.EGG_SERVER_ENV = options.env;
+	return new EggLoader({
+		baseDir: options.baseDir,
+		logger,
+		app: Object.create(Application.prototype),
+		EggCoreClass: EggCore
+	});
+}
+async function findEggCore(options) {
+	const baseDirRealpath = await realpath(options.baseDir);
+	const paths = [await realpath(options.framework), baseDirRealpath];
+	try {
+		const { EggCore, EggLoader } = await importModule("egg", { paths });
+		if (EggLoader) return {
+			EggCore,
+			EggLoader
+		};
+	} catch (err) {
+		debug("[findEggCore] import \"egg\" from paths:%o error: %o", paths, err);
+	}
+	const names = ["@eggjs/core", "egg-core"];
+	for (const name of names) {
+		try {
+			const { EggCore, EggLoader } = await importModule(name, { paths });
+			if (EggLoader) return {
+				EggCore,
+				EggLoader
+			};
+		} catch (err) {
+			debug("[findEggCore] import \"%s\" from paths:%o error: %o", name, paths, err);
+		}
+		try {
+			const { EggCore, EggLoader } = await importModule(name);
+			if (EggLoader) return {
+				EggCore,
+				EggLoader
+			};
+		} catch (err) {
+			debug("[findEggCore] import \"%s\" error: %o", name, err);
+		}
+		let eggCorePath = path.join(options.baseDir, `node_modules/${name}`);
+		if (!await exists(eggCorePath)) eggCorePath = path.join(options.framework, `node_modules/${name}`);
+		if (await exists(eggCorePath)) return await importModule(eggCorePath);
+	}
+	assert(false, `Can't find ${names.join(" or ")} from ${options.baseDir} and ${options.framework}`);
+}
+
+//#endregion
+//#region src/deprecated.ts
+/**
+* Try to get framework dir path
+* If can't find any framework, try to find egg dir path
+*
+* @param {String} cwd - current work path
+* @param {Array} [eggNames] - egg names, default is ['egg']
+* @return {String} framework or egg dir path
+* @deprecated
+*/
+function getFrameworkOrEggPath(cwd, eggNames) {
+	eggNames = eggNames || ["egg"];
+	const moduleDir = path.join(cwd, "node_modules");
+	if (!existsSync(moduleDir)) return "";
+	const pkgFile = path.join(cwd, "package.json");
+	if (existsSync(pkgFile)) {
+		const pkg = readJSONSync(pkgFile);
+		if (pkg.egg && pkg.egg.framework) return path.join(moduleDir, pkg.egg.framework);
+	}
+	const names = readdirSync(moduleDir);
+	for (const name of names) {
+		const pkgfile = path.join(moduleDir, name, "package.json");
+		if (!existsSync(pkgfile)) continue;
+		const pkg = readJSONSync(pkgfile);
+		if (pkg.dependencies) {
+			for (const eggName of eggNames) if (pkg.dependencies[eggName]) return path.join(moduleDir, name);
+		}
+	}
+	for (const eggName of eggNames) {
+		const pkgfile = path.join(moduleDir, eggName, "package.json");
+		if (existsSync(pkgfile)) return path.join(moduleDir, eggName);
+	}
+	return "";
+}
+
+//#endregion
 //#region src/index.ts
 var src_default = {
 	getFrameworkPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/utils",
-  "version": "5.0.0-beta.19",
+  "version": "5.0.0-beta.20",
   "engines": {
     "node": ">=22.18.0"
   },

package/dist/_virtual/rolldown_runtime.js

@@ -1,7 +0,0 @@
-import { createRequire } from "node:module";
-
-//#region rolldown:runtime
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-//#endregion
-export { __require };

package/dist/deprecated.d.ts

@@ -1,13 +0,0 @@
-//#region src/deprecated.d.ts
-/**
- * Try to get framework dir path
- * If can't find any framework, try to find egg dir path
- *
- * @param {String} cwd - current work path
- * @param {Array} [eggNames] - egg names, default is ['egg']
- * @return {String} framework or egg dir path
- * @deprecated
- */
-declare function getFrameworkOrEggPath(cwd: string, eggNames?: string[]): string;
-//#endregion
-export { getFrameworkOrEggPath };

package/dist/deprecated.js

@@ -1,41 +0,0 @@
-import { readJSONSync } from "./utils.js";
-import path from "node:path";
-import { existsSync, readdirSync } from "node:fs";
-
-//#region src/deprecated.ts
-/**
-* Try to get framework dir path
-* If can't find any framework, try to find egg dir path
-*
-* @param {String} cwd - current work path
-* @param {Array} [eggNames] - egg names, default is ['egg']
-* @return {String} framework or egg dir path
-* @deprecated
-*/
-function getFrameworkOrEggPath(cwd, eggNames) {
-	eggNames = eggNames || ["egg"];
-	const moduleDir = path.join(cwd, "node_modules");
-	if (!existsSync(moduleDir)) return "";
-	const pkgFile = path.join(cwd, "package.json");
-	if (existsSync(pkgFile)) {
-		const pkg = readJSONSync(pkgFile);
-		if (pkg.egg && pkg.egg.framework) return path.join(moduleDir, pkg.egg.framework);
-	}
-	const names = readdirSync(moduleDir);
-	for (const name of names) {
-		const pkgfile = path.join(moduleDir, name, "package.json");
-		if (!existsSync(pkgfile)) continue;
-		const pkg = readJSONSync(pkgfile);
-		if (pkg.dependencies) {
-			for (const eggName of eggNames) if (pkg.dependencies[eggName]) return path.join(moduleDir, name);
-		}
-	}
-	for (const eggName of eggNames) {
-		const pkgfile = path.join(moduleDir, eggName, "package.json");
-		if (existsSync(pkgfile)) return path.join(moduleDir, eggName);
-	}
-	return "";
-}
-
-//#endregion
-export { getFrameworkOrEggPath };

package/dist/error/ImportResolveError.d.ts

@@ -1,8 +0,0 @@
-//#region src/error/ImportResolveError.d.ts
-declare class ImportResolveError extends Error {
-  filepath: string;
-  paths: string[];
-  constructor(filepath: string, paths: string[], error: Error);
-}
-//#endregion
-export { ImportResolveError };

package/dist/error/ImportResolveError.js

@@ -1,16 +0,0 @@
-//#region src/error/ImportResolveError.ts
-var ImportResolveError = class extends Error {
-	filepath;
-	paths;
-	constructor(filepath, paths, error) {
-		const message = `${error.message}, paths: ${JSON.stringify(paths)}`;
-		super(message, { cause: error });
-		this.name = this.constructor.name;
-		this.filepath = filepath;
-		this.paths = paths;
-		Error.captureStackTrace(this, this.constructor);
-	}
-};
-
-//#endregion
-export { ImportResolveError };

package/dist/framework.d.ts

@@ -1,18 +0,0 @@
-//#region src/framework.d.ts
-interface Options {
-  baseDir: string;
-  framework?: string;
-}
-/**
- * Find the framework directory, lookup order
- * - specify framework path
- * - get framework name from
- * - use egg by default
- * @param {Object} options - options
- * @param  {String} options.baseDir - the current directory of application
- * @param  {String} [options.framework] - the directory of framework
- * @return {String} frameworkPath
- */
-declare function getFrameworkPath(options: Options): string;
-//#endregion
-export { getFrameworkPath };

package/dist/framework.js

@@ -1,60 +0,0 @@
-import { readJSONSync } from "./utils.js";
-import { importResolve } from "./import.js";
-import path from "node:path";
-import { debuglog } from "node:util";
-import assert from "node:assert";
-import { existsSync } from "node:fs";
-
-//#region src/framework.ts
-const debug = debuglog("egg/utils/framework");
-const initCwd = process.cwd();
-/**
-* Find the framework directory, lookup order
-* - specify framework path
-* - get framework name from
-* - use egg by default
-* @param {Object} options - options
-* @param  {String} options.baseDir - the current directory of application
-* @param  {String} [options.framework] - the directory of framework
-* @return {String} frameworkPath
-*/
-function getFrameworkPath(options) {
-	const { framework, baseDir } = options;
-	const pkgPath = path.join(baseDir, "package.json");
-	assert(existsSync(pkgPath), `${pkgPath} should exist`);
-	const moduleDir = path.join(baseDir, "node_modules");
-	if (framework) {
-		if (path.isAbsolute(framework)) {
-			assert(existsSync(framework), `${framework} should exist`);
-			return framework;
-		}
-		return assertAndReturn(framework, moduleDir, baseDir);
-	}
-	const pkg = readJSONSync(pkgPath);
-	if (pkg.egg?.framework) return assertAndReturn(pkg.egg.framework, moduleDir, baseDir);
-	return assertAndReturn("egg", moduleDir, baseDir);
-}
-function assertAndReturn(frameworkName, moduleDir, baseDir) {
-	const moduleDirs = new Set([
-		moduleDir,
-		path.join(process.cwd(), "node_modules"),
-		path.join(initCwd, "node_modules")
-	]);
-	try {
-		let globalModuleDir;
-		if (frameworkName.startsWith("@") && frameworkName.includes("/")) globalModuleDir = path.join(importResolve(`${frameworkName}/package.json`, { paths: [baseDir] }), "../../..");
-		else globalModuleDir = path.join(importResolve(`${frameworkName}/package.json`, { paths: [baseDir] }), "../..");
-		moduleDirs.add(globalModuleDir);
-	} catch {}
-	for (const moduleDir$1 of moduleDirs) {
-		const frameworkPath = path.join(moduleDir$1, frameworkName);
-		if (existsSync(frameworkPath)) {
-			debug("[assertAndReturn] frameworkPath: %s, moduleDirs: %o", frameworkPath, moduleDirs);
-			return frameworkPath;
-		}
-	}
-	throw new Error(`${frameworkName} is not found in ${Array.from(moduleDirs)}`);
-}
-
-//#endregion
-export { getFrameworkPath };

package/dist/import.d.ts

@@ -1,15 +0,0 @@
-//#region src/import.d.ts
-interface ImportResolveOptions {
-  paths?: string[];
-}
-interface ImportModuleOptions extends ImportResolveOptions {
-  importDefaultOnly?: boolean;
-}
-declare let isESM: boolean;
-declare function getRequire(): NodeRequire;
-declare function getExtensions(): NodeJS.RequireExtensions;
-declare function isSupportTypeScript(): boolean;
-declare function importResolve(filepath: string, options?: ImportResolveOptions): string;
-declare function importModule(filepath: string, options?: ImportModuleOptions): Promise<any>;
-//#endregion
-export { ImportModuleOptions, ImportResolveOptions, getExtensions, getRequire, importModule, importResolve, isESM, isSupportTypeScript };

package/dist/import.js

@@ -1,231 +0,0 @@
-import { __require } from "./_virtual/rolldown_runtime.js";
-import { ImportResolveError } from "./error/ImportResolveError.js";
-import { createRequire } from "node:module";
-import path from "node:path";
-import { debuglog } from "node:util";
-import fs from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-//#region src/import.ts
-const debug = debuglog("egg/utils/import");
-let isESM = true;
-try {
-	if (typeof import.meta !== "undefined") isESM = true;
-} catch {
-	isESM = false;
-}
-const supportImportMetaResolve = parseInt(process.versions.node.split(".", 1)[0], 10) >= 18;
-let _customRequire;
-function getRequire() {
-	if (!_customRequire) if (typeof __require !== "undefined") _customRequire = __require;
-	else _customRequire = createRequire(process.cwd());
-	return _customRequire;
-}
-function getExtensions() {
-	return getRequire().extensions;
-}
-let _supportTypeScript;
-function isSupportTypeScript() {
-	if (_supportTypeScript === void 0) {
-		const extensions = getExtensions();
-		_supportTypeScript = extensions[".ts"] !== void 0 || process.env.VITEST === "true" || process.env.EGG_TS_ENABLE === "true" || parseInt(process.versions.node.split(".", 1)[0], 10) >= 22;
-		debug("[isSupportTypeScript] %o, extensions: %j, process.env.VITEST: %j, process.env.EGG_TS_ENABLE: %j, node version: %s", _supportTypeScript, Object.keys(extensions), process.env.VITEST, process.env.EGG_TS_ENABLE, process.versions.node);
-	}
-	return _supportTypeScript;
-}
-function tryToResolveFromFile(filepath) {
-	const type = isESM ? "module" : "commonjs";
-	let mainIndexFile = "";
-	if (type === "module") {
-		mainIndexFile = filepath + ".mjs";
-		if (fs.existsSync(mainIndexFile)) {
-			debug("[tryToResolveFromFile] %o, use index.mjs, type: %o", mainIndexFile, type);
-			return mainIndexFile;
-		}
-		mainIndexFile = filepath + ".js";
-		if (fs.existsSync(mainIndexFile)) {
-			debug("[tryToResolveFromFile] %o, use index.js, type: %o", mainIndexFile, type);
-			return mainIndexFile;
-		}
-	} else {
-		mainIndexFile = filepath + ".cjs";
-		if (fs.existsSync(mainIndexFile)) {
-			debug("[tryToResolveFromFile] %o, use index.cjs, type: %o", mainIndexFile, type);
-			return mainIndexFile;
-		}
-		mainIndexFile = filepath + ".js";
-		if (fs.existsSync(mainIndexFile)) {
-			debug("[tryToResolveFromFile] %o, use index.js, type: %o", mainIndexFile, type);
-			return mainIndexFile;
-		}
-	}
-	if (!isSupportTypeScript()) return;
-	mainIndexFile = filepath + ".ts";
-	if (fs.existsSync(mainIndexFile)) {
-		debug("[tryToResolveFromFile] %o, use index.ts, type: %o", mainIndexFile, type);
-		return mainIndexFile;
-	}
-}
-function tryToResolveByDirnameFromPackage(dirname, pkg) {
-	const defaultMainFile = isESM ? pkg.module ?? pkg.main : pkg.main;
-	if (defaultMainFile) {
-		const mainIndexFilePath$1 = path.join(dirname, defaultMainFile);
-		if (fs.existsSync(mainIndexFilePath$1)) {
-			debug("[tryToResolveByDirnameFromPackage] %o, use pkg.main or pkg.module: %o, isESM: %s", mainIndexFilePath$1, defaultMainFile, isESM);
-			return mainIndexFilePath$1;
-		}
-	}
-	if (pkg.exports?.["."]) {
-		const pkgType = pkg.type ?? "commonjs";
-		const defaultExport = pkg.exports["."];
-		let mainIndexFilePath$1 = "";
-		if (typeof defaultExport === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport);
-		else if (pkgType === "module") {
-			if (typeof defaultExport.import === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport.import);
-			else if (typeof defaultExport.import?.default === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport.import.default);
-		} else if (typeof defaultExport.require === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport.require);
-		else if (typeof defaultExport.require?.default === "string") mainIndexFilePath$1 = path.join(dirname, defaultExport.require.default);
-		if (mainIndexFilePath$1 && fs.existsSync(mainIndexFilePath$1)) {
-			debug("[tryToResolveByDirnameFromPackage] %o, use pkg.exports[.]: %o, pkg.type: %o", mainIndexFilePath$1, defaultExport, pkgType);
-			return mainIndexFilePath$1;
-		}
-	}
-	const type = pkg?.type ?? (isESM ? "module" : "commonjs");
-	if (type === "module") {
-		const mainIndexFilePath$1 = path.join(dirname, "index.mjs");
-		if (fs.existsSync(mainIndexFilePath$1)) {
-			debug("[tryToResolveByDirnameFromPackage] %o, use index.mjs, pkg.type: %o", mainIndexFilePath$1, type);
-			return mainIndexFilePath$1;
-		}
-		const mainIndexMjsFilePath = path.join(dirname, "index.js");
-		if (fs.existsSync(mainIndexMjsFilePath)) {
-			debug("[tryToResolveByDirnameFromPackage] %o, use index.js, pkg.type: %o", mainIndexMjsFilePath, type);
-			return mainIndexMjsFilePath;
-		}
-	} else {
-		const mainIndexFilePath$1 = path.join(dirname, "index.cjs");
-		if (fs.existsSync(mainIndexFilePath$1)) {
-			debug("[tryToResolveByDirnameFromPackage] %o, use index.cjs, pkg.type: %o", mainIndexFilePath$1, type);
-			return mainIndexFilePath$1;
-		}
-		const mainIndexCjsFilePath = path.join(dirname, "index.js");
-		if (fs.existsSync(mainIndexCjsFilePath)) {
-			debug("[tryToResolveByDirnameFromPackage] %o, use index.js, pkg.type: %o", mainIndexCjsFilePath, type);
-			return mainIndexCjsFilePath;
-		}
-	}
-	if (!isSupportTypeScript()) return;
-	const mainIndexFile = pkg.tshy?.exports?.["."] ?? "index.ts";
-	const mainIndexFilePath = path.join(dirname, mainIndexFile);
-	if (fs.existsSync(mainIndexFilePath)) return mainIndexFilePath;
-}
-function tryToResolveByDirname(dirname) {
-	let pkg = {};
-	const pkgFile = path.join(dirname, "package.json");
-	if (fs.existsSync(pkgFile)) pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
-	return tryToResolveByDirnameFromPackage(dirname, pkg);
-}
-function isRelativePath(filepath) {
-	return filepath.startsWith("./") || filepath.startsWith("../") || filepath.startsWith(".\\") || filepath.startsWith("..\\");
-}
-function tryToResolveFromAbsoluteFile(filepath) {
-	let moduleFilePath;
-	const stat = fs.statSync(filepath, { throwIfNoEntry: false });
-	if (stat?.isDirectory()) {
-		moduleFilePath = tryToResolveByDirname(filepath);
-		if (moduleFilePath) return moduleFilePath;
-	} else if (stat?.isFile()) return filepath;
-	moduleFilePath = tryToResolveFromFile(filepath);
-	if (moduleFilePath) return moduleFilePath;
-	const parentDir = path.dirname(filepath);
-	const basename = path.basename(filepath);
-	const pkgFile = path.join(parentDir, "package.json");
-	if (fs.existsSync(pkgFile)) {
-		const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
-		const key = `./${basename}`;
-		if (pkg.exports?.[key]) return path.join(parentDir, pkg.exports[key]);
-	}
-}
-function importResolve(filepath, options) {
-	const paths = options?.paths ?? [process.cwd()];
-	debug("[importResolve] filepath: %o, options: %j, paths: %j", filepath, options, paths);
-	let moduleFilePath;
-	const isAbsolute = path.isAbsolute(filepath);
-	if (isAbsolute) {
-		moduleFilePath = tryToResolveFromAbsoluteFile(filepath);
-		if (moduleFilePath) {
-			debug("[importResolve:isAbsolute] %o => %o", filepath, moduleFilePath);
-			return moduleFilePath;
-		}
-	} else if (isRelativePath(filepath)) for (const p of paths) {
-		const resolvedPath = path.resolve(p, filepath);
-		moduleFilePath = tryToResolveFromAbsoluteFile(resolvedPath);
-		if (moduleFilePath) {
-			debug("[importResolve:isRelativePath] %o => %o => %o", filepath, resolvedPath, moduleFilePath);
-			return moduleFilePath;
-		}
-	}
-	for (const p of paths) {
-		let resolvedPath = path.join(p, "node_modules", filepath);
-		moduleFilePath = tryToResolveFromAbsoluteFile(resolvedPath);
-		if (moduleFilePath) {
-			debug("[importResolve:node_modules] %o => %o => %o", filepath, resolvedPath, moduleFilePath);
-			return moduleFilePath;
-		}
-		let parentPath = path.dirname(p);
-		if (path.basename(parentPath) === "node_modules") {
-			resolvedPath = path.join(parentPath, filepath);
-			moduleFilePath = tryToResolveFromAbsoluteFile(resolvedPath);
-			if (moduleFilePath) {
-				debug("[importResolve:node_modules] %o => %o => %o", filepath, resolvedPath, moduleFilePath);
-				return moduleFilePath;
-			}
-		}
-		parentPath = path.dirname(parentPath);
-		if (path.basename(parentPath) === "node_modules") {
-			resolvedPath = path.join(parentPath, filepath);
-			moduleFilePath = tryToResolveFromAbsoluteFile(resolvedPath);
-			if (moduleFilePath) {
-				debug("[importResolve:node_modules] %o => %o => %o", filepath, resolvedPath, moduleFilePath);
-				return moduleFilePath;
-			}
-		}
-	}
-	const extname = path.extname(filepath);
-	if (!isAbsolute && extname === ".json" || !isESM) moduleFilePath = getRequire().resolve(filepath, { paths });
-	else if (supportImportMetaResolve) {
-		try {
-			moduleFilePath = import.meta.resolve(filepath);
-		} catch (err) {
-			debug("[importResolve:error] import.meta.resolve %o => %o, options: %o", filepath, err, options);
-			throw new ImportResolveError(filepath, paths, err);
-		}
-		if (moduleFilePath.startsWith("file://")) moduleFilePath = fileURLToPath(moduleFilePath);
-		debug("[importResolve] import.meta.resolve %o => %o", filepath, moduleFilePath);
-		if (!fs.statSync(moduleFilePath, { throwIfNoEntry: false })?.isFile()) throw new TypeError(`Cannot find module ${filepath}, because ${moduleFilePath} does not exists`);
-	} else moduleFilePath = getRequire().resolve(filepath);
-	debug("[importResolve:success] %o, options: %o => %o, isESM: %s", filepath, options, moduleFilePath, isESM);
-	return moduleFilePath;
-}
-async function importModule(filepath, options) {
-	const moduleFilePath = importResolve(filepath, options);
-	let obj;
-	if (isESM) {
-		const fileUrl = pathToFileURL(moduleFilePath).toString();
-		obj = await import(fileUrl);
-		debug("[importModule:success] await import %o", fileUrl);
-		if (obj?.default?.__esModule === true && "default" in obj?.default) obj = obj.default;
-		if (options?.importDefaultOnly) {
-			if ("default" in obj) obj = obj.default;
-		}
-	} else {
-		obj = __require(moduleFilePath);
-		debug("[importModule] require %o", moduleFilePath);
-		if (obj?.__esModule === true && "default" in obj) obj = obj.default;
-	}
-	if (debug.enabled) debug("[importModule] return %o => keys: %j, typeof obj: %s", filepath, obj ? Object.keys(obj) : obj, typeof obj);
-	return obj;
-}
-
-//#endregion
-export { getExtensions, getRequire, importModule, importResolve, isESM, isSupportTypeScript };

package/dist/plugin.d.ts

@@ -1,51 +0,0 @@
-//#region src/plugin.d.ts
-interface LoaderOptions {
-  framework: string;
-  baseDir: string;
-  env?: string;
-}
-interface Plugin {
-  name: string;
-  version?: string;
-  enable: boolean;
-  implicitEnable: boolean;
-  path: string;
-  dependencies: string[];
-  optionalDependencies: string[];
-  env: string[];
-  from: string;
-}
-/**
- * @see https://github.com/eggjs/egg-core/blob/2920f6eade07959d25f5c4f96b154d3fbae877db/lib/loader/mixin/plugin.js#L203
- */
-declare function getPlugins(options: LoaderOptions): Promise<Record<string, Plugin>>;
-interface Unit {
-  type: 'plugin' | 'framework' | 'app';
-  path: string;
-}
-/**
- * @see https://github.com/eggjs/egg-core/blob/2920f6eade07959d25f5c4f96b154d3fbae877db/lib/loader/egg_loader.js#L348
- */
-declare function getLoadUnits(options: LoaderOptions): Promise<Unit[]>;
-declare function getConfig(options: LoaderOptions): Promise<Record<string, any>>;
-interface IEggLoader {
-  loadPlugin(): Promise<void>;
-  loadConfig(): Promise<void>;
-  config: Record<string, any>;
-  getLoadUnits(): Unit[];
-  allPlugins: Record<string, Plugin>;
-}
-interface IEggLoaderOptions {
-  baseDir: string;
-  app: unknown;
-  logger: object;
-  EggCoreClass?: unknown;
-}
-type EggLoaderImplClass<T = IEggLoader> = new (options: IEggLoaderOptions) => T;
-declare function getLoader(options: LoaderOptions): Promise<IEggLoader>;
-declare function findEggCore(options: LoaderOptions): Promise<{
-  EggCore?: object;
-  EggLoader: EggLoaderImplClass;
-}>;
-//#endregion
-export { findEggCore, getConfig, getLoadUnits, getLoader, getPlugins };

package/dist/plugin.js

@@ -1,112 +0,0 @@
-import { importModule } from "./import.js";
-import path from "node:path";
-import { mkdir, realpath, stat, writeFile } from "node:fs/promises";
-import { debuglog } from "node:util";
-import assert from "node:assert";
-import os from "node:os";
-
-//#region src/plugin.ts
-const debug = debuglog("egg/utils/plugin");
-const tmpDir = os.tmpdir();
-function noop() {}
-const logger = {
-	debug: noop,
-	info: noop,
-	warn: noop,
-	error: noop
-};
-/**
-* @see https://github.com/eggjs/egg-core/blob/2920f6eade07959d25f5c4f96b154d3fbae877db/lib/loader/mixin/plugin.js#L203
-*/
-async function getPlugins(options) {
-	const loader = await getLoader(options);
-	await loader.loadPlugin();
-	return loader.allPlugins;
-}
-/**
-* @see https://github.com/eggjs/egg-core/blob/2920f6eade07959d25f5c4f96b154d3fbae877db/lib/loader/egg_loader.js#L348
-*/
-async function getLoadUnits(options) {
-	const loader = await getLoader(options);
-	await loader.loadPlugin();
-	return loader.getLoadUnits();
-}
-async function getConfig(options) {
-	const loader = await getLoader(options);
-	await loader.loadPlugin();
-	await loader.loadConfig();
-	return loader.config;
-}
-async function exists(filepath) {
-	try {
-		await stat(filepath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function getLoader(options) {
-	assert(options.framework, "framework is required");
-	assert(await exists(options.framework), `${options.framework} should exist`);
-	if (!(options.baseDir && await exists(options.baseDir))) {
-		options.baseDir = path.join(tmpDir, "egg_utils", `${Date.now()}`, "tmp_app");
-		await mkdir(options.baseDir, { recursive: true });
-		await writeFile(path.join(options.baseDir, "package.json"), JSON.stringify({
-			name: "tmp_app",
-			type: "module"
-		}));
-		debug("[getLoader] create baseDir: %o", options.baseDir);
-	}
-	const { EggCore, EggLoader } = await findEggCore(options);
-	const mod = await importModule(options.framework);
-	const Application = mod.Application ?? mod.default?.Application;
-	assert(Application, `Application not export on ${options.framework}`);
-	if (options.env) process.env.EGG_SERVER_ENV = options.env;
-	return new EggLoader({
-		baseDir: options.baseDir,
-		logger,
-		app: Object.create(Application.prototype),
-		EggCoreClass: EggCore
-	});
-}
-async function findEggCore(options) {
-	const baseDirRealpath = await realpath(options.baseDir);
-	const paths = [await realpath(options.framework), baseDirRealpath];
-	try {
-		const { EggCore, EggLoader } = await importModule("egg", { paths });
-		if (EggLoader) return {
-			EggCore,
-			EggLoader
-		};
-	} catch (err) {
-		debug("[findEggCore] import \"egg\" from paths:%o error: %o", paths, err);
-	}
-	const names = ["@eggjs/core", "egg-core"];
-	for (const name of names) {
-		try {
-			const { EggCore, EggLoader } = await importModule(name, { paths });
-			if (EggLoader) return {
-				EggCore,
-				EggLoader
-			};
-		} catch (err) {
-			debug("[findEggCore] import \"%s\" from paths:%o error: %o", name, paths, err);
-		}
-		try {
-			const { EggCore, EggLoader } = await importModule(name);
-			if (EggLoader) return {
-				EggCore,
-				EggLoader
-			};
-		} catch (err) {
-			debug("[findEggCore] import \"%s\" error: %o", name, err);
-		}
-		let eggCorePath = path.join(options.baseDir, `node_modules/${name}`);
-		if (!await exists(eggCorePath)) eggCorePath = path.join(options.framework, `node_modules/${name}`);
-		if (await exists(eggCorePath)) return await importModule(eggCorePath);
-	}
-	assert(false, `Can't find ${names.join(" or ")} from ${options.baseDir} and ${options.framework}`);
-}
-
-//#endregion
-export { findEggCore, getConfig, getLoadUnits, getLoader, getPlugins };

package/dist/utils.js

@@ -1,12 +0,0 @@
-import path from "node:path";
-import { existsSync, readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-//#region src/utils.ts
-function readJSONSync(file) {
-	if (!existsSync(file)) throw new Error(`${file} is not found`);
-	return JSON.parse(readFileSync(file, "utf-8"));
-}
-
-//#endregion
-export { readJSONSync };