@eggjs/utils 4.4.1 → 4.5.0-beta.2

package/README.md

@@ -1,16 +1,11 @@
 # @eggjs/utils
 
 [![NPM version][npm-image]][npm-url]
-[![CI](https://github.com/eggjs/utils/actions/workflows/nodejs.yml/badge.svg)](https://github.com/eggjs/utils/actions/workflows/nodejs.yml)
-[![Test coverage][codecov-image]][codecov-url]
 [![npm download][download-image]][download-url]
 [![Node.js Version](https://img.shields.io/node/v/@eggjs/utils.svg?style=flat)](https://nodejs.org/en/download/)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
 
 [npm-image]: https://img.shields.io/npm/v/@eggjs/utils.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/@eggjs/utils
-[codecov-image]: https://codecov.io/github/eggjs/utils/coverage.svg?branch=master
-[codecov-url]: https://codecov.io/github/eggjs/utils?branch=master
 [download-image]: https://img.shields.io/npm/dm/@eggjs/utils.svg?style=flat-square
 [download-url]: https://npmjs.org/package/@eggjs/utils
 
@@ -53,6 +48,6 @@ npm i @eggjs/utils
 
 ## Contributors
 
-[![Contributors](https://contrib.rocks/image?repo=eggjs/utils)](https://github.com/eggjs/utils/graphs/contributors)
+[![Contributors](https://contrib.rocks/image?repo=eggjs/egg)](https://github.com/eggjs/egg/graphs/contributors)
 
 Made with [contributors-img](https://contrib.rocks).

package/dist/_virtual/rolldown_runtime.js

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

package/dist/{commonjs/deprecated.d.ts → deprecated.d.ts}

@@ -1,3 +1,4 @@
+//#region src/deprecated.d.ts
 /**
  * Try to get framework dir path
  * If can't find any framework, try to find egg dir path
@@ -7,4 +8,6 @@
  * @return {String} framework or egg dir path
  * @deprecated
  */
-export declare function getFrameworkOrEggPath(cwd: string, eggNames?: string[]): string;
+declare function getFrameworkOrEggPath(cwd: string, eggNames?: string[]): string;
+//#endregion
+export { getFrameworkOrEggPath };

package/dist/deprecated.js

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

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

@@ -0,0 +1,16 @@
+//#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/{commonjs/framework.d.ts → framework.d.ts}

@@ -1,6 +1,7 @@
+//#region src/framework.d.ts
 interface Options {
-    baseDir: string;
-    framework?: string;
+  baseDir: string;
+  framework?: string;
 }
 /**
  * Find the framework directory, lookup order
@@ -12,5 +13,6 @@ interface Options {
  * @param  {String} [options.framework] - the directory of framework
  * @return {String} frameworkPath
  */
-export declare function getFrameworkPath(options: Options): string;
-export {};
+declare function getFrameworkPath(options: Options): string;
+//#endregion
+export { getFrameworkPath };

package/dist/framework.js

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

@@ -0,0 +1,14 @@
+//#region src/import.d.ts
+interface ImportResolveOptions {
+  paths?: string[];
+}
+interface ImportModuleOptions extends ImportResolveOptions {
+  importDefaultOnly?: boolean;
+}
+declare let isESM: boolean;
+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, importModule, importResolve, isESM, isSupportTypeScript };

package/dist/import.js

@@ -0,0 +1,231 @@
+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, importModule, importResolve, isESM, isSupportTypeScript };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { getFrameworkPath } from "./framework.js";
+import { findEggCore, getConfig, getLoadUnits, getLoader, getPlugins } from "./plugin.js";
+import { getFrameworkOrEggPath } from "./deprecated.js";
+import { ImportModuleOptions, ImportResolveOptions, getExtensions, importModule, importResolve, isESM, isSupportTypeScript } from "./import.js";
+import { ImportResolveError } from "./error/ImportResolveError.js";
+
+//#region src/index.d.ts
+
+declare const _default: {
+  getFrameworkPath: typeof getFrameworkPath;
+  getPlugins: typeof getPlugins;
+  getConfig: typeof getConfig;
+  getLoadUnits: typeof getLoadUnits;
+  getFrameworkOrEggPath: typeof getFrameworkOrEggPath;
+};
+declare const EggType: {
+  readonly framework: "framework";
+  readonly plugin: "plugin";
+  readonly application: "application";
+  readonly unknown: "unknown";
+};
+type EggType = (typeof EggType)[keyof typeof EggType];
+/**
+ * Detect the type of egg project
+ */
+declare function detectType(baseDir: string): Promise<keyof typeof EggType>;
+//#endregion
+export { EggType, ImportModuleOptions, ImportResolveError, ImportResolveOptions, _default as default, detectType, findEggCore, getConfig, getExtensions, getFrameworkOrEggPath, getFrameworkPath, getLoadUnits, getLoader, getPlugins, importModule, importResolve, isESM, isSupportTypeScript };

package/dist/index.js

@@ -0,0 +1,45 @@
+import { ImportResolveError } from "./error/ImportResolveError.js";
+import { getExtensions, 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 path from "node:path";
+import fs from "node:fs/promises";
+
+//#region src/index.ts
+var src_default = {
+	getFrameworkPath,
+	getPlugins,
+	getConfig,
+	getLoadUnits,
+	getFrameworkOrEggPath
+};
+const EggType = {
+	framework: "framework",
+	plugin: "plugin",
+	application: "application",
+	unknown: "unknown"
+};
+/**
+* Detect the type of egg project
+*/
+async function detectType(baseDir) {
+	const pkgFile = path.join(baseDir, "package.json");
+	let pkg;
+	try {
+		await fs.access(pkgFile);
+	} catch {
+		return EggType.unknown;
+	}
+	try {
+		pkg = JSON.parse(await fs.readFile(pkgFile, "utf-8"));
+	} catch {
+		return EggType.unknown;
+	}
+	if (pkg.egg?.framework) return EggType.framework;
+	if (pkg.eggPlugin?.name) return EggType.plugin;
+	return EggType.application;
+}
+
+//#endregion
+export { EggType, ImportResolveError, src_default as default, detectType, findEggCore, getConfig, getExtensions, getFrameworkOrEggPath, getFrameworkPath, getLoadUnits, getLoader, getPlugins, importModule, importResolve, isESM, isSupportTypeScript };

package/dist/plugin.d.ts

@@ -0,0 +1,51 @@
+//#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 };