@eggjs/core 6.5.0 → 6.6.0-beta.11

package/README.md

@@ -1,16 +1,12 @@
 # @eggjs/core
 
 [![NPM version][npm-image]][npm-url]
-[![Node.js CI](https://github.com/eggjs/core/actions/workflows/nodejs.yml/badge.svg)](https://github.com/eggjs/core/actions/workflows/nodejs.yml)
-[![Test coverage][codecov-image]][codecov-url]
 [![Known Vulnerabilities][snyk-image]][snyk-url]
 [![npm download][download-image]][download-url]
 [![Node.js Version](https://img.shields.io/node/v/@eggjs/core.svg?style=flat)](https://nodejs.org/en/download/)
 
 [npm-image]: https://img.shields.io/npm/v/@eggjs/core.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/@eggjs/core
-[codecov-image]: https://codecov.io/github/eggjs/core/coverage.svg?branch=master
-[codecov-url]: https://codecov.io/github/eggjs/core?branch=master
 [snyk-image]: https://snyk.io/test/npm/@eggjs/core/badge.svg?style=flat-square
 [snyk-url]: https://snyk.io/test/npm/@eggjs/core
 [download-image]: https://img.shields.io/npm/dm/@eggjs/core.svg?style=flat-square
@@ -285,7 +281,7 @@ Please open an issue [here](https://github.com/eggjs/egg/issues).
 
 ## Contributors
 
-[![Contributors](https://contrib.rocks/image?repo=eggjs/core)](https://github.com/eggjs/core/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/base_context_class.d.ts

@@ -0,0 +1,21 @@
+import { Context, EggCore } from "./egg.js";
+
+//#region src/base_context_class.d.ts
+
+/**
+ * BaseContextClass is a base class that can be extended,
+ * it's instantiated in context level,
+ * {@link Helper}, {@link Service} is extending it.
+ */
+declare class BaseContextClass {
+  ctx: Context;
+  app: EggCore;
+  config: Record<string, any>;
+  service: BaseContextClass;
+  /**
+   * @since 1.0.0
+   */
+  constructor(ctx: Context);
+}
+//#endregion
+export { BaseContextClass };

package/dist/base_context_class.js

@@ -0,0 +1,40 @@
+//#region src/base_context_class.ts
+/**
+* BaseContextClass is a base class that can be extended,
+* it's instantiated in context level,
+* {@link Helper}, {@link Service} is extending it.
+*/
+var BaseContextClass = class {
+	ctx;
+	app;
+	config;
+	service;
+	/**
+	* @since 1.0.0
+	*/
+	constructor(ctx) {
+		/**
+		* @member {Context} BaseContextClass#ctx
+		* @since 1.0.0
+		*/
+		this.ctx = ctx;
+		/**
+		* @member {Application} BaseContextClass#app
+		* @since 1.0.0
+		*/
+		this.app = ctx.app;
+		/**
+		* @member {Config} BaseContextClass#config
+		* @since 1.0.0
+		*/
+		this.config = ctx.app.config;
+		/**
+		* @member {Service} BaseContextClass#service
+		* @since 1.0.0
+		*/
+		this.service = ctx.service;
+	}
+};
+
+//#endregion
+export { BaseContextClass };

package/dist/egg.d.ts

@@ -0,0 +1,248 @@
+import { Fun } from "./utils/index.js";
+import { EggAppConfig, EggPluginInfo } from "./types.js";
+import { BaseContextClass } from "./base_context_class.js";
+import { Timing } from "./utils/timing.js";
+import { Lifecycle } from "./lifecycle.js";
+import { EggLoader } from "./loader/egg_loader.js";
+import { SingletonCreateMethod } from "./singleton.js";
+import { Application as KoaApplication, Context as KoaContext, MiddlewareFunc as KoaMiddlewareFunc, Next, Request as KoaRequest, Response as KoaResponse } from "@eggjs/koa";
+import { EggConsoleLogger, Logger } from "egg-logger";
+import { EggRouter as Router, RegisterOptions, ResourcesController } from "@eggjs/router";
+import { ReadyFunctionArg } from "get-ready";
+
+//#region src/egg.d.ts
+declare const EGG_LOADER: unique symbol;
+interface EggCoreOptions {
+  baseDir: string;
+  type: 'application' | 'agent';
+  plugins?: any;
+  serverScope?: string;
+  env?: string;
+}
+type EggCoreInitOptions = Partial<EggCoreOptions>;
+declare class Request$1 extends KoaRequest {
+  app: EggCore;
+  response: Response$1;
+}
+declare class Response$1 extends KoaResponse {
+  app: EggCore;
+  request: Request$1;
+}
+declare class Context$1 extends KoaContext {
+  app: EggCore;
+  request: Request$1;
+  response: Response$1;
+  service: BaseContextClass;
+  /**
+   * Returns map of URL parameters for given `path` and `paramNames`.
+   * @example
+   * ##### ctx.params.id {string}
+   *
+   * `GET /api/users/1` => `'1'`
+   *
+   * ##### ctx.params.per_page {string}
+   *
+   * The number of every page, `GET /api/users?per_page=20` => `20`
+   */
+  params?: Record<string, string>;
+  /**
+   * Returns array of router regexp url path captures.
+   */
+  captures?: string[];
+  /**
+   * Returns the name of the matched router.
+   */
+  routerName?: string;
+  /**
+   * Returns the path of the matched router.
+   */
+  routerPath?: string | RegExp;
+}
+type MiddlewareFunc<T extends KoaContext = Context$1> = KoaMiddlewareFunc<T>;
+declare class EggCore extends KoaApplication {
+  #private;
+  options: EggCoreOptions;
+  timing: Timing;
+  console: EggConsoleLogger;
+  BaseContextClass: typeof BaseContextClass;
+  Controller: typeof BaseContextClass;
+  Service: typeof BaseContextClass;
+  Helper?: typeof BaseContextClass;
+  lifecycle: Lifecycle;
+  loader: EggLoader;
+  /** auto inject on loadService() */
+  readonly serviceClasses: Record<string, any>;
+  /** auto inject on loadController() */
+  readonly controller: Record<string, any>;
+  /** auto inject on loadMiddleware() */
+  readonly middlewares: Record<string, (opt: unknown, app: EggCore) => MiddlewareFunc>;
+  /**
+   * @class
+   * @param {Object} options - options
+   * @param {String} [options.baseDir] - the directory of application
+   * @param {String} [options.type] - whether it's running in app worker or agent worker
+   * @param {Object} [options.plugins] - custom plugins
+   * @since 1.0.0
+   */
+  constructor(options?: EggCoreInitOptions);
+  get logger(): Logger;
+  get coreLogger(): Logger;
+  /**
+   * create a singleton instance
+   * @param {String} name - unique name for singleton
+   * @param {Function|AsyncFunction} create - method will be invoked when singleton instance create
+   */
+  addSingleton(name: string, create: SingletonCreateMethod): void;
+  /**
+   * override koa's app.use, support generator function
+   * @since 1.0.0
+   */
+  use<T extends KoaContext = Context$1>(fn: MiddlewareFunc<T>): this;
+  /**
+   * Whether `application` or `agent`
+   * @member {String}
+   * @since 1.0.0
+   */
+  get type(): "application" | "agent";
+  /**
+   * The current directory of application
+   * @member {String}
+   * @see {@link AppInfo#baseDir}
+   * @since 1.0.0
+   */
+  get baseDir(): string;
+  /**
+   * Alias to {@link https://npmjs.com/package/depd}
+   * @member {Function}
+   * @since 1.0.0
+   */
+  get deprecate(): (message: string) => void;
+  /**
+   * The name of application
+   * @member {String}
+   * @see {@link AppInfo#name}
+   * @since 1.0.0
+   */
+  get name(): any;
+  /**
+   * Retrieve enabled plugins
+   * @member {Object}
+   * @since 1.0.0
+   */
+  get plugins(): Record<string, EggPluginInfo>;
+  /**
+   * The configuration of application
+   * @member {Config}
+   * @since 1.0.0
+   */
+  get config(): EggAppConfig;
+  /**
+   * Execute scope after loaded and before app start.
+   *
+   * Notice:
+   * This method is now NOT recommended and regarded as a deprecated one,
+   * For plugin development, we should use `didLoad` instead.
+   * For application development, we should use `willReady` instead.
+   *
+   * @see https://eggjs.org/en/advanced/loader.html#beforestart
+   *
+   * @param  {Function} scope function will execute before app start
+   * @param {string} [name] scope name, default is empty string
+   */
+  beforeStart(scope: Fun, name?: string): void;
+  /**
+   * register an callback function that will be invoked when application is ready.
+   * @see https://github.com/node-modules/get-ready
+   * @since 1.0.0
+   * @example
+   * const app = new Application(...);
+   * app.ready(err => {
+   *   if (err) throw err;
+   *   console.log('done');
+   * });
+   */
+  ready(): Promise<void>;
+  ready(flagOrFunction: ReadyFunctionArg): void;
+  /**
+   * If a client starts asynchronously, you can register `readyCallback`,
+   * then the application will wait for the callback to ready
+   *
+   * It will log when the callback is not invoked after 10s
+   *
+   * Recommend to use {@link EggCore#beforeStart}
+   * @since 1.0.0
+   *
+   * @param {String} name - readyCallback task name
+   * @param {object} opts -
+   *   - {Number} [timeout=10000] - emit `ready_timeout` when it doesn't finish but reach the timeout
+   *   - {Boolean} [isWeakDep=false] - whether it's a weak dependency
+   * @returns {Function} - a callback
+   * @example
+   * const done = app.readyCallback('mysql');
+   * mysql.ready(done);
+   */
+  readyCallback(name: string, opts: object): (...args: unknown[]) => void;
+  /**
+   * Register a function that will be called when app close.
+   *
+   * Notice:
+   * This method is now NOT recommended directly used,
+   * Developers SHOULDN'T use app.beforeClose directly now,
+   * but in the form of class to implement beforeClose instead.
+   *
+   * @see https://eggjs.org/en/advanced/loader.html#beforeclose
+   *
+   * @param {Function} fn - the function that can be generator function or async function.
+   */
+  beforeClose(fn: Fun, name?: string): void;
+  /**
+   * Close all, it will close
+   * - callbacks registered by beforeClose
+   * - emit `close` event
+   * - remove add listeners
+   *
+   * If error is thrown when it's closing, the promise will reject.
+   * It will also reject after following call.
+   * @returns {Promise} promise
+   * @since 1.0.0
+   */
+  close(): Promise<void>;
+  /**
+   * get router
+   * @member {Router} EggCore#router
+   * @since 1.0.0
+   */
+  get router(): Router;
+  /**
+   * Alias to {@link Router#url}
+   * @param {String} name - Router name
+   * @param {Object} params - more parameters
+   * @returns {String} url
+   */
+  url(name: string, params?: Parameters<Router['url']>[1]): string;
+  head(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  head(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  get(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  get(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  put(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  put(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  patch(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  patch(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  post(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  post(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  delete(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  delete(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  del(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  del(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  all(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  all(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  resources(prefix: string, controller: string | ResourcesController): EggCore;
+  resources(prefix: string, middleware: MiddlewareFunc, controller: string | ResourcesController): EggCore;
+  resources(name: string, prefix: string, controller: string | ResourcesController): EggCore;
+  resources(name: string, prefix: string, middleware: MiddlewareFunc, controller: string | ResourcesController): EggCore;
+  redirect(source: string, destination: string, status?: number): this;
+  register(path: string | RegExp | (string | RegExp)[], methods: string[], middleware: MiddlewareFunc | MiddlewareFunc[], opts?: RegisterOptions): this;
+  get [EGG_LOADER](): typeof EggLoader;
+}
+//#endregion
+export { Context$1 as Context, EGG_LOADER, EggCore, EggCoreInitOptions, EggCoreOptions, KoaApplication, KoaContext, type KoaMiddlewareFunc, KoaRequest, KoaResponse, MiddlewareFunc, type Next, Request$1 as Request, Response$1 as Response, Router };

package/dist/egg.js

@@ -0,0 +1,358 @@
+import utils_default from "./utils/index.js";
+import { BaseContextClass } from "./base_context_class.js";
+import { Timing } from "./utils/timing.js";
+import { Lifecycle } from "./lifecycle.js";
+import { EggLoader } from "./loader/egg_loader.js";
+import { Singleton } from "./singleton.js";
+import { debuglog } from "node:util";
+import assert from "node:assert";
+import { Application as KoaApplication, Context as KoaContext, Request as KoaRequest, Response as KoaResponse } from "@eggjs/koa";
+import { EggConsoleLogger } from "egg-logger";
+import { EggRouter as Router } from "@eggjs/router";
+
+//#region src/egg.ts
+const debug = debuglog("egg/core/egg");
+const EGG_LOADER = Symbol.for("egg#loader");
+var Request$1 = class extends KoaRequest {};
+var Response$1 = class extends KoaResponse {};
+var Context$1 = class extends KoaContext {
+	/**
+	* Returns map of URL parameters for given `path` and `paramNames`.
+	* @example
+	* ##### ctx.params.id {string}
+	*
+	* `GET /api/users/1` => `'1'`
+	*
+	* ##### ctx.params.per_page {string}
+	*
+	* The number of every page, `GET /api/users?per_page=20` => `20`
+	*/
+	params;
+	/**
+	* Returns array of router regexp url path captures.
+	*/
+	captures;
+	/**
+	* Returns the name of the matched router.
+	*/
+	routerName;
+	/**
+	* Returns the path of the matched router.
+	*/
+	routerPath;
+};
+var EggCore = class EggCore extends KoaApplication {
+	options;
+	timing;
+	console;
+	BaseContextClass;
+	Controller;
+	Service;
+	Helper;
+	lifecycle;
+	loader;
+	#closePromise;
+	#router;
+	/** auto inject on loadService() */
+	serviceClasses = {};
+	/** auto inject on loadController() */
+	controller = {};
+	/** auto inject on loadMiddleware() */
+	middlewares = {};
+	/**
+	* @class
+	* @param {Object} options - options
+	* @param {String} [options.baseDir] - the directory of application
+	* @param {String} [options.type] - whether it's running in app worker or agent worker
+	* @param {Object} [options.plugins] - custom plugins
+	* @since 1.0.0
+	*/
+	constructor(options = {}) {
+		options.baseDir = options.baseDir ?? process.cwd();
+		options.type = options.type ?? "application";
+		assert(typeof options.baseDir === "string", "options.baseDir required, and must be a string");
+		assert(options.type === "application" || options.type === "agent", "options.type should be application or agent");
+		super();
+		this.timing = new Timing();
+		/**
+		* @member {Object} EggCore#options
+		* @private
+		* @since 1.0.0
+		*/
+		this.options = options;
+		/**
+		* logging for EggCore, avoid using console directly
+		* @member {Logger} EggCore#console
+		* @private
+		* @since 1.0.0
+		*/
+		this.console = new EggConsoleLogger();
+		/**
+		* @member {BaseContextClass} EggCore#BaseContextClass
+		* @since 1.0.0
+		*/
+		this.BaseContextClass = BaseContextClass;
+		/**
+		* Retrieve base controller
+		* @member {Controller} EggCore#Controller
+		* @since 1.0.0
+		*/
+		this.Controller = this.BaseContextClass;
+		/**
+		* Retrieve base service
+		* @member {Service} EggCore#Service
+		* @since 1.0.0
+		*/
+		this.Service = this.BaseContextClass;
+		this.lifecycle = new Lifecycle({
+			baseDir: options.baseDir,
+			app: this,
+			logger: this.console
+		});
+		this.lifecycle.on("error", (err) => this.emit("error", err));
+		this.lifecycle.on("ready_timeout", (id) => this.emit("ready_timeout", id));
+		this.lifecycle.on("ready_stat", (data) => this.emit("ready_stat", data));
+		/**
+		* The loader instance, the default class is {@link EggLoader}.
+		* If you want define
+		* @member {EggLoader} EggCore#loader
+		* @since 1.0.0
+		*/
+		const Loader = this[EGG_LOADER];
+		assert(Loader, "Symbol.for('egg#loader') is required");
+		this.loader = new Loader({
+			baseDir: options.baseDir,
+			app: this,
+			plugins: options.plugins,
+			logger: this.console,
+			serverScope: options.serverScope,
+			env: options.env ?? "",
+			EggCoreClass: EggCore
+		});
+	}
+	get logger() {
+		return this.console;
+	}
+	get coreLogger() {
+		return this.console;
+	}
+	/**
+	* create a singleton instance
+	* @param {String} name - unique name for singleton
+	* @param {Function|AsyncFunction} create - method will be invoked when singleton instance create
+	*/
+	addSingleton(name, create) {
+		const initPromise = new Singleton({
+			name,
+			create,
+			app: this
+		}).init();
+		if (initPromise) this.lifecycle.registerBeforeStart(async () => {
+			await initPromise;
+		}, `${name}-singleton-init`);
+	}
+	/**
+	* override koa's app.use, support generator function
+	* @since 1.0.0
+	*/
+	use(fn) {
+		assert(typeof fn === "function", "app.use() requires a function");
+		debug("[use] add middleware: %o", fn._name || fn.name || "-");
+		this.middleware.push(fn);
+		return this;
+	}
+	/**
+	* Whether `application` or `agent`
+	* @member {String}
+	* @since 1.0.0
+	*/
+	get type() {
+		return this.options.type;
+	}
+	/**
+	* The current directory of application
+	* @member {String}
+	* @see {@link AppInfo#baseDir}
+	* @since 1.0.0
+	*/
+	get baseDir() {
+		return this.options.baseDir;
+	}
+	/**
+	* Alias to {@link https://npmjs.com/package/depd}
+	* @member {Function}
+	* @since 1.0.0
+	*/
+	get deprecate() {
+		return utils_default.deprecated;
+	}
+	/**
+	* The name of application
+	* @member {String}
+	* @see {@link AppInfo#name}
+	* @since 1.0.0
+	*/
+	get name() {
+		return this.loader ? this.loader.pkg.name : "";
+	}
+	/**
+	* Retrieve enabled plugins
+	* @member {Object}
+	* @since 1.0.0
+	*/
+	get plugins() {
+		return this.loader ? this.loader.plugins : {};
+	}
+	/**
+	* The configuration of application
+	* @member {Config}
+	* @since 1.0.0
+	*/
+	get config() {
+		return this.loader ? this.loader.config : {};
+	}
+	/**
+	* Execute scope after loaded and before app start.
+	*
+	* Notice:
+	* This method is now NOT recommended and regarded as a deprecated one,
+	* For plugin development, we should use `didLoad` instead.
+	* For application development, we should use `willReady` instead.
+	*
+	* @see https://eggjs.org/en/advanced/loader.html#beforestart
+	*
+	* @param  {Function} scope function will execute before app start
+	* @param {string} [name] scope name, default is empty string
+	*/
+	beforeStart(scope, name) {
+		this.deprecate("`beforeStart` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		this.lifecycle.registerBeforeStart(scope, name ?? "");
+	}
+	ready(flagOrFunction) {
+		if (flagOrFunction === void 0) return this.lifecycle.ready();
+		return this.lifecycle.ready(flagOrFunction);
+	}
+	/**
+	* If a client starts asynchronously, you can register `readyCallback`,
+	* then the application will wait for the callback to ready
+	*
+	* It will log when the callback is not invoked after 10s
+	*
+	* Recommend to use {@link EggCore#beforeStart}
+	* @since 1.0.0
+	*
+	* @param {String} name - readyCallback task name
+	* @param {object} opts -
+	*   - {Number} [timeout=10000] - emit `ready_timeout` when it doesn't finish but reach the timeout
+	*   - {Boolean} [isWeakDep=false] - whether it's a weak dependency
+	* @returns {Function} - a callback
+	* @example
+	* const done = app.readyCallback('mysql');
+	* mysql.ready(done);
+	*/
+	readyCallback(name, opts) {
+		this.deprecate("`readyCallback` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		return this.lifecycle.legacyReadyCallback(name, opts);
+	}
+	/**
+	* Register a function that will be called when app close.
+	*
+	* Notice:
+	* This method is now NOT recommended directly used,
+	* Developers SHOULDN'T use app.beforeClose directly now,
+	* but in the form of class to implement beforeClose instead.
+	*
+	* @see https://eggjs.org/en/advanced/loader.html#beforeclose
+	*
+	* @param {Function} fn - the function that can be generator function or async function.
+	*/
+	beforeClose(fn, name) {
+		this.deprecate("`beforeClose` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		this.lifecycle.registerBeforeClose(fn, name);
+	}
+	/**
+	* Close all, it will close
+	* - callbacks registered by beforeClose
+	* - emit `close` event
+	* - remove add listeners
+	*
+	* If error is thrown when it's closing, the promise will reject.
+	* It will also reject after following call.
+	* @returns {Promise} promise
+	* @since 1.0.0
+	*/
+	async close() {
+		if (this.#closePromise) return this.#closePromise;
+		this.#closePromise = this.lifecycle.close();
+		return this.#closePromise;
+	}
+	/**
+	* get router
+	* @member {Router} EggCore#router
+	* @since 1.0.0
+	*/
+	get router() {
+		if (this.#router) return this.#router;
+		this.#router = new Router({ sensitive: true }, this);
+		return this.#router;
+	}
+	/**
+	* Alias to {@link Router#url}
+	* @param {String} name - Router name
+	* @param {Object} params - more parameters
+	* @returns {String} url
+	*/
+	url(name, params) {
+		return this.router.url(name, params);
+	}
+	head(...args) {
+		this.router.head.apply(this.router, args);
+		return this;
+	}
+	get(...args) {
+		this.router.get.apply(this.router, args);
+		return this;
+	}
+	put(...args) {
+		this.router.put.apply(this.router, args);
+		return this;
+	}
+	patch(...args) {
+		this.router.patch.apply(this.router, args);
+		return this;
+	}
+	post(...args) {
+		this.router.post.apply(this.router, args);
+		return this;
+	}
+	delete(...args) {
+		this.router.delete.apply(this.router, args);
+		return this;
+	}
+	del(...args) {
+		this.router.del.apply(this.router, args);
+		return this;
+	}
+	all(...args) {
+		this.router.all.apply(this.router, args);
+		return this;
+	}
+	resources(...args) {
+		this.router.resources.apply(this.router, args);
+		return this;
+	}
+	redirect(source, destination, status = 301) {
+		this.router.redirect(source, destination, status);
+		return this;
+	}
+	register(path, methods, middleware, opts) {
+		this.router.register(path, methods, middleware, opts);
+		return this;
+	}
+	get [EGG_LOADER]() {
+		return EggLoader;
+	}
+};
+
+//#endregion
+export { Context$1 as Context, EGG_LOADER, EggCore, KoaApplication, KoaContext, KoaRequest, KoaResponse, Request$1 as Request, Response$1 as Response, Router };