koatty 4.1.6 → 4.1.8

package/dist/index.js

@@ -1,591 +1,866 @@
+'use strict';
+
+var koatty_config = require('koatty_config');
+var koatty_container = require('koatty_container');
+var koatty_core = require('koatty_core');
+var koatty_exception = require('koatty_exception');
+var koatty_lib = require('koatty_lib');
+var koatty_router = require('koatty_router');
+var koatty_serve = require('koatty_serve');
+var koatty_logger = require('koatty_logger');
+var koatty_loader = require('koatty_loader');
+var koatty_trace = require('koatty_trace');
+var path = require('path');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
 /*!
 * @Author: richen
-* @Date: 2026-02-04 10:57:35
+* @Date: 2026-02-10 09:13:30
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
 */
-"use strict";
-
-var e = require("koatty_config");
-
-var t = require("koatty_container");
-
-var o = require("koatty_core");
-
-var a = require("koatty_exception");
-
-var r = require("koatty_lib");
-
-var n = require("koatty_router");
-
-var s = require("koatty_serve");
-
-var i = require("koatty_logger");
-
-var l = require("koatty_loader");
-
-var c = require("koatty_trace");
-
-var p = require("path");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 
-function f(e) {
-  var t = Object.create(null);
-  if (e) Object.keys(e).forEach(function(o) {
-    if (o !== "default") {
-      var a = Object.getOwnPropertyDescriptor(e, o);
-      Object.defineProperty(t, o, a.get ? a : {
-        enumerable: !0,
-        get: function() {
-          return e[o];
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports$1, module) {
+    module.exports = {
+      name: "koatty",
+      version: "4.1.8",
+      description: "Koa + Typescript = koatty. Use Typescript's decorator implement auto injection.",
+      scripts: {
+        build: "pnpm run build:js && pnpm run build:dts && pnpm run build:doc && pnpm run build:cp",
+        "build:js": "tsup",
+        "build:dts": "bash scripts/build-dts.sh",
+        "build:doc": "api-documenter markdown --input temp --output docs/api",
+        "build:cp": "node scripts/copyFiles && node ../../scripts/postBuild.js",
+        clean: "rimraf dist temp docs/api",
+        lint: "eslint --ext .ts,.js ./src",
+        test: "pnpm run lint && jest --passWithNoTests",
+        "test:cov": "jest --collectCoverage --detectOpenHandles"
+      },
+      main: "./dist/index.js",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.mjs",
+          require: "./dist/index.js"
         }
-      });
+      },
+      keywords: [
+        "koatty",
+        "koa",
+        "typescript",
+        "framework",
+        "mvc",
+        "http",
+        "https",
+        "websocket",
+        "grpc",
+        "quic",
+        "http2",
+        "http3",
+        "di",
+        "aop",
+        "ioc",
+        "inversion of control",
+        "dependency injection",
+        "aspect-oriented programming",
+        "decorator",
+        "decorator pattern",
+        "decorator factory"
+      ],
+      directories: {
+        doc: "docs"
+      },
+      repository: {
+        type: "git",
+        url: "git+https://github.com/koatty/koatty.git"
+      },
+      engines: {
+        node: ">=18.0.0"
+      },
+      author: {
+        name: "richenlin",
+        email: "richenlin@gmail.com"
+      },
+      license: "BSD-3-Clause",
+      bugs: {
+        url: "https://github.com/koatty/koatty/issues"
+      },
+      homepage: "https://github.com/koatty/koatty",
+      maintainers: [
+        {
+          name: "richenlin",
+          email: "richenlin@gmail.com"
+        }
+      ],
+      devDependencies: {
+        "@grpc/grpc-js": "^1.12.2",
+        "@microsoft/api-documenter": "^7.26.x",
+        "@microsoft/api-extractor": "^7.52.x",
+        "@types/formidable": "^3.x.x",
+        "@types/jest": "^29.5.x",
+        "@types/koa": "^2.x.x",
+        "@types/koa-compose": "^3.x.x",
+        "@types/lodash": "^4.x.x",
+        "@types/node": "^22.x.x",
+        "@types/on-finished": "^2.x.x",
+        "@types/supertest": "^6.x.x",
+        "@types/ws": "^8.x.x",
+        "@typescript-eslint/eslint-plugin": "^8.x.x",
+        "@typescript-eslint/parser": "^8.x.x",
+        eslint: "^8.x.x",
+        "eslint-plugin-jest": "^28.x.x",
+        jest: "^29.x.x",
+        "jest-html-reporters": "^3.x.x",
+        koatty_validation: "workspace:*",
+        "reflect-metadata": "^0.2.2",
+        supertest: "^7.x.x",
+        "ts-jest": "^29.x.x",
+        tslib: "^2.x.x"
+      },
+      dependencies: {
+        koa: "^3.1.1",
+        koatty_config: "workspace:*",
+        koatty_container: "workspace:*",
+        koatty_core: "workspace:*",
+        koatty_exception: "workspace:*",
+        koatty_lib: "workspace:*",
+        koatty_loader: "workspace:*",
+        koatty_logger: "workspace:*",
+        koatty_router: "workspace:*",
+        koatty_serve: "workspace:*",
+        koatty_trace: "workspace:*",
+        "ts-morph": "^27.0.2"
+      },
+      types: "./dist/index.d.ts"
+    };
+  }
+});
+var pkg = require_package();
+var { engines, version } = pkg;
+var KOATTY_VERSION = version;
+var ENGINES_VERSION = engines.node.slice(1) || "12.0.0";
+function checkClass(fileName, xpath, target, exSet) {
+  if (koatty_lib.Helper.isClass(target) && target.name != fileName) {
+    throw Error(`The file(${xpath}) name should be always the same as class name.`);
+  }
+  if (target["__esModule"]) {
+    if (target.name === void 0) {
+      const keys = Object.keys(target);
+      if (keys[0] != fileName && koatty_lib.Helper.isClass(target[keys[0]])) {
+        throw Error(`The file(${xpath}) name should be always the same as class name.`);
+      }
+    } else if (target.name != fileName) {
+      throw Error(`The file(${xpath}) name should be always the same as class name.`);
     }
-  });
-  t.default = e;
-  return Object.freeze(t);
-}
-
-var g = f(p);
-
-/*
- * @Description: framework helper
- * @Usage:
- * @Author: richen
- * @Date: 2023-12-09 21:56:32
- * @LastEditTime: 2025-01-14 16:14:10
- * @License: BSD (3-Clause)
- * @Copyright (c): <richenlin(at)gmail.com>
- */ const d = require("../../package.json");
-
-const {engines: u, version: y} = d;
-
-const L = y;
-
-const v = u.node.slice(1) || "12.0.0";
-
-function m(e, t, o, a) {
-  if (r.Helper.isClass(o) && o.name != e) throw Error(`The file(${t}) name should be always the same as class name.`);
-  if (o["__esModule"]) if (o.name === void 0) {
-    const a = Object.keys(o);
-    if (a[0] != e && r.Helper.isClass(o[a[0]])) throw Error(`The file(${t}) name should be always the same as class name.`);
-  } else if (o.name != e) throw Error(`The file(${t}) name should be always the same as class name.`);
-  if (!a) return;
-  if (a.has(e)) throw new Error(`A same class already exists. at \`${t}\`.`);
-  a.add(e);
+  }
+  if (!exSet) {
+    return;
+  }
+  if (exSet.has(fileName)) {
+    throw new Error(`A same class already exists. at \`${xpath}\`.`);
+  }
+  exSet.add(fileName);
   return;
 }
-
-function h() {
-  let e = v;
-  e = e.slice(0, e.lastIndexOf("."));
-  let t = process.version;
-  if (t[0] === "v") t = t.slice(1);
-  t = t.slice(0, t.lastIndexOf("."));
-  if (r.Helper.toNumber(e) > r.Helper.toNumber(t)) i.DefaultLogger.Fatal(`Koatty need node version > ${e}, current version is ${t}, please upgrade it.`);
+__name(checkClass, "checkClass");
+function checkRuntime() {
+  let nodeEngines = ENGINES_VERSION;
+  nodeEngines = nodeEngines.slice(0, nodeEngines.lastIndexOf("."));
+  let nodeVersion = process.version;
+  if (nodeVersion[0] === "v") {
+    nodeVersion = nodeVersion.slice(1);
+  }
+  nodeVersion = nodeVersion.slice(0, nodeVersion.lastIndexOf("."));
+  if (koatty_lib.Helper.toNumber(nodeEngines) > koatty_lib.Helper.toNumber(nodeVersion)) {
+    koatty_logger.DefaultLogger.Fatal(`Koatty need node version > ${nodeEngines}, current version is ${nodeVersion}, please upgrade it.`);
+  }
 }
-
-const C = () => {
-  let e = !1;
-  const t = JSON.stringify(process.argv[1]);
-  if (t.indexOf("jest") > -1) e = !0;
-  return e;
-};
-
-/*
- * @Description: framework constants
- * @Usage:
- * @Author: richen
- * @Date: 2023-12-09 21:56:32
- * @LastEditTime: 2023-12-09 23:00:13
- * @License: BSD (3-Clause)
- * @Copyright (c): <richenlin(at)gmail.com>
- */ const E = "COMPONENT_SCAN";
-
-const O = "CONFIGURATION_SCAN";
-
-const w = `\n\n┬┌─┌─┐┌─┐┌┬┐┌┬┐┬ ┬\n├┴┐│ │├─┤ │  │ └┬┘\n┴ ┴└─┘┴ ┴ ┴  ┴  ┴ \n-------------------------------------------\nhttps://github.com/koatty\n`
-/*
- * @Description: framework loader
- * @Usage:
- * @Author: richen
- * @Date: 2023-12-09 22:55:49
- * @LastEditTime: 2025-03-13 16:44:39
- * @License: BSD (3-Clause)
- * @Copyright (c): <richenlin(at)gmail.com>
- */;
-
-class Loader {
-  constructor(e) {
-    this.app = e;
+__name(checkRuntime, "checkRuntime");
+var checkUTRuntime = /* @__PURE__ */ __name(() => {
+  let isUTRuntime = false;
+  const argv = JSON.stringify(process.argv[1]);
+  if (argv.indexOf("jest") > -1) {
+    isUTRuntime = true;
+  }
+  return isUTRuntime;
+}, "checkUTRuntime");
+
+// src/core/Constants.ts
+var COMPONENT_SCAN = "COMPONENT_SCAN";
+var CONFIGURATION_SCAN = "CONFIGURATION_SCAN";
+var LOGO = `
+
+\u252C\u250C\u2500\u250C\u2500\u2510\u250C\u2500\u2510\u250C\u252C\u2510\u250C\u252C\u2510\u252C \u252C
+\u251C\u2534\u2510\u2502 \u2502\u251C\u2500\u2524 \u2502  \u2502 \u2514\u252C\u2518
+\u2534 \u2534\u2514\u2500\u2518\u2534 \u2534 \u2534  \u2534  \u2534 
+-------------------------------------------
+https://github.com/koatty
+`;
+var Loader = class _Loader {
+  static {
+    __name(this, "Loader");
   }
-  static initialize(e) {
-    if (e.env == "development") i.DefaultLogger.setLevel("debug"); else i.DefaultLogger.setLevel("info");
-    const t = e.rootPath || process.cwd();
-    const o = e.appPath || g.resolve(t, e.appDebug ? "src" : "dist");
-    const a = g.resolve(__dirname, "..");
-    r.Helper.define(e, "rootPath", t);
-    r.Helper.define(e, "appPath", o);
-    r.Helper.define(e, "koattyPath", a);
-    if (r.Helper.isEmpty(e.name)) {
-      const t = r.Helper.safeRequire(`${g.dirname(o)}/package.json`);
-      if (t.name) {
-        e.name = t.name;
-        e.version = e.version || t.version;
+  app;
+  /**
+  * Creates an instance of Loader.
+  * @param {KoattyApplication} app
+  * @memberof Loader
+  */
+  constructor(app) {
+    this.app = app;
+  }
+  /**
+  * Initialize application configuration and environment settings.
+  * Sets up logging levels, defines essential paths, and loads application metadata.
+  *
+  * @param {KoattyApplication} app - The Koatty application instance
+  * - Sets logging level based on environment
+  * - Defines root, app and framework paths on app object
+  * - Loads application name and version from package.json
+  * - Sets environment variables for paths
+  * - Maintains backward compatibility with legacy path variables
+  */
+  static initialize(app) {
+    if (app.env == "development") {
+      koatty_logger.DefaultLogger.setLevel("debug");
+    } else {
+      koatty_logger.DefaultLogger.setLevel("info");
+    }
+    const rootPath = app.rootPath || process.cwd();
+    const appPath = app.appPath || path__namespace.resolve(rootPath, app.appDebug ? "src" : "dist");
+    const koattyPath = path__namespace.resolve(__dirname, "..");
+    koatty_lib.Helper.define(app, "rootPath", rootPath);
+    koatty_lib.Helper.define(app, "appPath", appPath);
+    koatty_lib.Helper.define(app, "koattyPath", koattyPath);
+    if (koatty_lib.Helper.isEmpty(app.name)) {
+      const pkg2 = koatty_lib.Helper.safeRequire(`${path__namespace.dirname(appPath)}/package.json`);
+      if (pkg2.name) {
+        app.name = pkg2.name;
+        app.version = app.version || pkg2.version;
       }
     }
-    process.env.ROOT_PATH = t;
-    process.env.APP_PATH = o;
-    process.env.KOATTY_PATH = a;
-    process.env.THINK_PATH = a;
-    r.Helper.define(e, "thinkPath", a);
+    process.env.ROOT_PATH = rootPath;
+    process.env.APP_PATH = appPath;
+    process.env.KOATTY_PATH = koattyPath;
+    process.env.THINK_PATH = koattyPath;
+    koatty_lib.Helper.define(app, "thinkPath", koattyPath);
   }
-  static GetComponentMeta(e, o) {
-    let a = [];
-    const n = t.IOC.getClassMetadata(t.TAGGED_CLS, E, o);
-    if (n) if (r.Helper.isArray(n)) a = n; else a.push(n);
-    if (a.length < 1) a = [ e.appPath ];
-    return a;
+  /**
+  * Get component metadata from target class.
+  * 
+  * @param {KoattyApplication} app - The Koatty application instance
+  * @param {any} target - The target class to get metadata from
+  * @returns {any[]} Array of component metadata paths
+  * 
+  * @static
+  * @public
+  */
+  static GetComponentMeta(app, target) {
+    let componentMetas = [];
+    const componentMeta = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, COMPONENT_SCAN, target);
+    if (componentMeta) {
+      if (koatty_lib.Helper.isArray(componentMeta)) {
+        componentMetas = componentMeta;
+      } else {
+        componentMetas.push(componentMeta);
+      }
+    }
+    if (componentMetas.length < 1) {
+      componentMetas = [
+        app.appPath
+      ];
+    }
+    return componentMetas;
   }
-  static GetConfigurationMeta(e, o) {
-    const a = t.IOC.getClassMetadata(t.TAGGED_CLS, O, o);
-    let n = [];
-    if (a) if (r.Helper.isArray(a)) n = a; else n.push(a);
-    return n;
+  /**
+  * Get configuration metadata from target class.
+  * 
+  * @param {KoattyApplication} app Application instance
+  * @param {any} target Target class
+  * @returns {any[]} Array of configuration metadata
+  */
+  static GetConfigurationMeta(app, target) {
+    const confMeta = koatty_container.IOC.getClassMetadata(koatty_container.TAGGED_CLS, CONFIGURATION_SCAN, target);
+    let configurationMetas = [];
+    if (confMeta) {
+      if (koatty_lib.Helper.isArray(confMeta)) {
+        configurationMetas = confMeta;
+      } else {
+        configurationMetas.push(confMeta);
+      }
+    }
+    return configurationMetas;
   }
-  static CheckAllComponents(e, t) {
-    const o = Loader.GetComponentMeta(e, t);
-    const a = Loader.GetConfigurationMeta(e, t);
-    const r = new Set;
-    l.Load(o, "", (e, t, o) => {
-      m(e, t, o, r);
-    }, [ "**/**.js", "**/**.ts", "!**/**.d.ts" ], [ ...a, `${t.name || ".no"}.ts` ]);
-    r.clear();
+  /**
+  * Check and load all components(excepted config/*、App.ts) in the application.
+  * 
+  * @param {KoattyApplication} app - The Koatty application instance
+  * @param {any} target - The target class or object to check components from
+  * @static
+  * @public
+  */
+  static CheckAllComponents(app, target) {
+    const componentMetas = _Loader.GetComponentMeta(app, target);
+    const configurationMetas = _Loader.GetConfigurationMeta(app, target);
+    const exSet = /* @__PURE__ */ new Set();
+    koatty_loader.Load(componentMetas, "", (fileName, xpath, xTarget) => {
+      checkClass(fileName, xpath, xTarget, exSet);
+    }, [
+      "**/**.js",
+      "**/**.ts",
+      "!**/**.d.ts"
+    ], [
+      ...configurationMetas,
+      `${target.name || ".no"}.ts`
+    ]);
+    exSet.clear();
   }
-  static SetLogger(e) {
-    const t = e.getMetaData("_configs") || [];
-    const a = t[0] || {};
-    if (a.config) {
-      const t = a.config;
-      let n = "debug", s = "", l = [];
-      if (e.env === "production") n = "info";
-      if (t.logsLevel) n = t.logsLevel.toLowerCase();
-      if (t.logsPath) s = t.logsPath;
-      if (t.sensFields) l = t.sensFields;
-      if (!e.appDebug) {
-        i.DefaultLogger.enableBatch(!0);
-        i.DefaultLogger.setBatchConfig({
+  /**
+  * Set logger configuration for the Koatty application.
+  * 
+  * @param {KoattyApplication} app - The Koatty application instance
+  * @description Configures logging settings based on application environment and config options.
+  * Handles log level, log file path, and sensitive fields configuration.
+  * In production environment, default log level is 'info', otherwise 'debug'.
+  */
+  static SetLogger(app) {
+    const data = app.getMetaData("_configs") || [];
+    const configs = data[0] || {};
+    if (configs.config) {
+      const opt = configs.config;
+      let logLevel = "debug", logFilePath = "", sensFields = [];
+      if (app.env === "production") {
+        logLevel = "info";
+      }
+      if (opt.logsLevel) {
+        logLevel = opt.logsLevel.toLowerCase();
+      }
+      if (opt.logsPath) {
+        logFilePath = opt.logsPath;
+      }
+      if (opt.sensFields) {
+        sensFields = opt.sensFields;
+      }
+      if (!app.appDebug) {
+        koatty_logger.DefaultLogger.enableBatch(true);
+        koatty_logger.DefaultLogger.setBatchConfig({
           maxSize: 200,
           flushInterval: 500
         });
       }
-      if (n) i.DefaultLogger.setLevel(n);
-      if (s && !e.silent) {
-        r.Helper.define(e, "logsPath", s);
-        process.env.LOGS_PATH = s;
-        i.DefaultLogger.setLogFilePath(s);
+      if (logLevel) {
+        koatty_logger.DefaultLogger.setLevel(logLevel);
+      }
+      if (logFilePath && !app.silent) {
+        koatty_lib.Helper.define(app, "logsPath", logFilePath);
+        process.env.LOGS_PATH = logFilePath;
+        koatty_logger.DefaultLogger.setLogFilePath(logFilePath);
       }
-      if (l) i.DefaultLogger.setSensFields(l);
-      e.once(o.AppEvent.appStop, async () => {
-        await i.DefaultLogger.flushBatch();
-        await i.DefaultLogger.destroy();
+      if (sensFields) {
+        koatty_logger.DefaultLogger.setSensFields(sensFields);
+      }
+      app.once(koatty_core.AppEvent.appStop, async () => {
+        await koatty_logger.DefaultLogger.flushBatch();
+        await koatty_logger.DefaultLogger.destroy();
       });
     }
   }
-  static async LoadAllComponents(e, a) {
+  /**
+  * Load all components and initialize the application.
+  * 
+  * @param app - The KoattyApplication instance
+  * @param target - The target class or object containing configuration metadata
+  * 
+  * This method performs the following initialization steps:
+  * 1. Loads configurations
+  * 2. Creates server and router instances
+  * 3. Loads components, middlewares, services and controllers
+  * 4. Sets up routing
+  * 
+  * @static
+  * @async
+  */
+  static async LoadAllComponents(app, target) {
     try {
-      if (r.Helper.isFunction(t.IOC.preloadMetadata)) t.IOC.preloadMetadata();
+      if (koatty_lib.Helper.isFunction(koatty_container.IOC.preloadMetadata)) {
+        koatty_container.IOC.preloadMetadata();
+      }
     } catch {
-      i.DefaultLogger.Warn("[Loader] preloadMetadata is optional, ignore if not available");
+      koatty_logger.DefaultLogger.Warn("[Loader] preloadMetadata is optional, ignore if not available");
     }
-    const n = Loader.GetConfigurationMeta(e, a);
-    const s = new Loader(e);
-    for (const t of o.AppEventArr) switch (t) {
-     case o.AppEvent.appBoot:
-      i.DefaultLogger.Log("Koatty", "", "Load Configurations ...");
-      s.LoadConfigs(n);
-      Loader.SetLogger(e);
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.loadConfigure:
-      i.DefaultLogger.Log("Koatty", "", "Emit loadConfigure ...");
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.loadComponent:
-      i.DefaultLogger.Log("Koatty", "", "Initializing Component Manager ...");
-      const l = new o.ComponentManager(e);
-      r.Helper.define(e, "componentManager", l);
-      l.discoverComponents();
-      const c = l.getStats();
-      i.DefaultLogger.Log("Koatty", "", `Discovered ${c.coreComponents} core components, ${c.userComponents} user components`);
-      i.DefaultLogger.Log("Koatty", "", "Load Components ...");
-      await s.LoadComponents(l);
-      l.registerAppEvents(a);
-      l.registerCoreComponentHooks();
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.loadPlugin:
-      i.DefaultLogger.Log("Koatty", "", "Emit loadPlugin ...");
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.loadMiddleware:
-      i.DefaultLogger.Log("Koatty", "", "Load Middlewares ...");
-      await s.LoadMiddlewares();
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.loadService:
-      i.DefaultLogger.Log("Koatty", "", "Load Services ...");
-      await s.LoadServices();
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.loadController:
-      i.DefaultLogger.Log("Koatty", "", "Load Controllers ...");
-      await s.LoadControllers();
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.loadRouter:
-      i.DefaultLogger.Log("Koatty", "", "Initialize Router and Load Routes ...");
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.loadServe:
-      i.DefaultLogger.Log("Koatty", "", "Emit loadServe ...");
-      await o.asyncEvent(e, t);
-      break;
-
-     case o.AppEvent.appReady:
-      i.DefaultLogger.Log("Koatty", "", "Emit appReady ...");
-      await o.asyncEvent(e, t);
-      break;
-
-     default:
-      await o.asyncEvent(e, t);
-      break;
+    const configurationMeta = _Loader.GetConfigurationMeta(app, target);
+    const loader = new _Loader(app);
+    for (const event of koatty_core.AppEventArr) {
+      switch (event) {
+        case koatty_core.AppEvent.appBoot:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Load Configurations ...");
+          loader.LoadConfigs(configurationMeta);
+          _Loader.SetLogger(app);
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.loadConfigure:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Emit loadConfigure ...");
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.loadComponent:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Initializing Component Manager ...");
+          const componentManager = new koatty_core.ComponentManager(app);
+          koatty_lib.Helper.define(app, "componentManager", componentManager);
+          componentManager.discoverComponents();
+          const stats = componentManager.getStats();
+          koatty_logger.DefaultLogger.Log("Koatty", "", `Discovered ${stats.coreComponents} core components, ${stats.userComponents} user components`);
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Load Components ...");
+          await loader.LoadComponents(componentManager);
+          componentManager.registerAppEvents(target);
+          componentManager.registerCoreComponentHooks();
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.loadPlugin:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Emit loadPlugin ...");
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.loadMiddleware:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Load Middlewares ...");
+          await loader.LoadMiddlewares();
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.loadService:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Load Services ...");
+          await loader.LoadServices();
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.loadController:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Load Controllers ...");
+          await loader.LoadControllers();
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.loadRouter:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Initialize Router and Load Routes ...");
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.loadServe:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Emit loadServe ...");
+          await koatty_core.asyncEvent(app, event);
+          break;
+        case koatty_core.AppEvent.appReady:
+          koatty_logger.DefaultLogger.Log("Koatty", "", "Emit appReady ...");
+          await koatty_core.asyncEvent(app, event);
+          break;
+        default:
+          await koatty_core.asyncEvent(app, event);
+          break;
+      }
     }
   }
-  LoadConfigs(t) {
-    const o = {};
-    l.Load([ "./config" ], this.app.koattyPath, function(e, t, a) {
-      o[e] = a;
+  /**
+  * Load configuration files from specified paths.
+  * First loads framework configurations from './config' directory,
+  * then loads application configurations from custom paths.
+  * Finally merges both configurations with framework configs as lower priority.
+  * 
+  * @protected
+  * @param {string[]} [loadPath] - Optional array of paths to load application configs from
+  */
+  LoadConfigs(loadPath) {
+    const frameConfig = {};
+    koatty_loader.Load([
+      "./config"
+    ], this.app.koattyPath, function(name, path2, exp) {
+      frameConfig[name] = exp;
     });
-    if (r.Helper.isArray(t)) t = t.length > 0 ? t : [ "./config" ];
-    let a = e.LoadConfigs(t, this.app.appPath);
-    a = r.Helper.extend(o, a, !0);
-    this.app.setMetaData("_configs", a);
+    if (koatty_lib.Helper.isArray(loadPath)) {
+      loadPath = loadPath.length > 0 ? loadPath : [
+        "./config"
+      ];
+    }
+    let appConfig = koatty_config.LoadConfigs(loadPath, this.app.appPath);
+    appConfig = koatty_lib.Helper.extend(frameConfig, appConfig, true);
+    this.app.setMetaData("_configs", appConfig);
   }
+  /**
+  * Load and register middleware components.
+  * Processes middleware configuration, registers middleware classes with IOC container,
+  * and mounts middleware to the application.
+  * Supports protocol-specific middleware mounting via @Middleware({ protocol }) option.
+  * 
+  * @protected
+  * @returns {Promise<void>}
+  * @throws {Error} When middleware doesn't implement IMiddleware interface
+  * @throws {Error} When middleware loading fails
+  */
   async LoadMiddlewares() {
-    var e, a, n, s;
-    let l = this.app.config(void 0, "middleware");
-    if (r.Helper.isEmpty(l)) l = {
-      config: {},
-      list: []
-    };
+    let middlewareConf = this.app.config(void 0, "middleware");
+    if (koatty_lib.Helper.isEmpty(middlewareConf)) {
+      middlewareConf = {
+        config: {},
+        list: []
+      };
+    }
     try {
-      const t = (a = (e = l.config) === null || e === void 0 ? void 0 : e.trace) !== null && a !== void 0 ? a : {};
-      const o = c.Trace(t, this.app);
-      r.Helper.define(this.app, "tracer", o);
-      this.app.use(o);
-      i.DefaultLogger.Debug(`Trace middleware registered`);
-    } catch (e) {
-      i.DefaultLogger.Warn(`Trace middleware failed to load: ${e.message}`);
+      const traceOptions = middlewareConf.config?.trace ?? {};
+      const tracer = koatty_trace.Trace(traceOptions, this.app);
+      koatty_lib.Helper.define(this.app, "tracer", tracer);
+      this.app.use(tracer);
+      koatty_logger.DefaultLogger.Debug(`Trace middleware registered`);
+    } catch (error) {
+      koatty_logger.DefaultLogger.Warn(`Trace middleware failed to load: ${error.message}`);
     }
-    const p = (n = t.IOC.listClass("MIDDLEWARE")) !== null && n !== void 0 ? n : [];
-    p.forEach(e => {
-      var a;
-      e.id = ((a = e.id) !== null && a !== void 0 ? a : "").replace("MIDDLEWARE:", "");
-      if (e.id && r.Helper.isClass(e.target)) {
-        t.IOC.reg(e.id, e.target, {
+    const appMiddleware = koatty_container.IOC.listClass("MIDDLEWARE") ?? [];
+    appMiddleware.forEach((item) => {
+      item.id = (item.id ?? "").replace("MIDDLEWARE:", "");
+      if (item.id && koatty_lib.Helper.isClass(item.target)) {
+        koatty_container.IOC.reg(item.id, item.target, {
           scope: "Prototype",
           type: "MIDDLEWARE",
           args: []
         });
-        const a = t.IOC.getInsByClass(e.target);
-        if (!o.implementsMiddlewareInterface(a)) throw Error(`The middleware ${e.id} must implements interface 'IMiddleware'.`);
+        const ctl = koatty_container.IOC.getInsByClass(item.target);
+        if (!koatty_core.implementsMiddlewareInterface(ctl)) {
+          throw Error(`The middleware ${item.id} must implements interface 'IMiddleware'.`);
+        }
       }
     });
-    const f = l.list || [];
-    const g = new Set([]);
-    f.forEach(e => {
-      g.add(e);
+    const middlewareList = middlewareConf.list || [];
+    const appMList = /* @__PURE__ */ new Set([]);
+    middlewareList.forEach((item) => {
+      appMList.add(item);
     });
-    const d = l.config || {};
-    for (const e of Array.from(g)) {
-      const a = t.IOC.get(e, "MIDDLEWARE");
-      if (!a) throw Error(`Middleware ${e} load error.`);
-      if (!r.Helper.isFunction(a.run)) throw Error(`The middleware ${e} must implements interface 'IMiddleware'.`);
-      i.DefaultLogger.Debug(`Load middleware: ${e}`);
-      const n = d[e] || {};
-      const l = (s = p.find(t => t.id === e)) === null || s === void 0 ? void 0 : s.target;
-      let c = {};
-      if (l) try {
-        c = t.IOC.getPropertyData(o.MIDDLEWARE_OPTIONS, l, e) || {};
-      } catch {
-        c = {};
+    const middlewareConfig = middlewareConf.config || {};
+    for (const key of Array.from(appMList)) {
+      const handle = koatty_container.IOC.get(key, "MIDDLEWARE");
+      if (!handle) {
+        throw Error(`Middleware ${key} load error.`);
+      }
+      if (!koatty_lib.Helper.isFunction(handle.run)) {
+        throw Error(`The middleware ${key} must implements interface 'IMiddleware'.`);
+      }
+      koatty_logger.DefaultLogger.Debug(`Load middleware: ${key}`);
+      const middlewareOpt = middlewareConfig[key] || {};
+      const middlewareClass = appMiddleware.find((m) => m.id === key)?.target;
+      let decoratorOptions = {};
+      if (middlewareClass) {
+        try {
+          decoratorOptions = koatty_container.IOC.getPropertyData(koatty_core.MIDDLEWARE_OPTIONS, middlewareClass, key) || {};
+        } catch {
+          decoratorOptions = {};
+        }
       }
-      const f = {
-        ...c,
-        ...n
+      const mergedOptions = {
+        ...decoratorOptions,
+        ...middlewareOpt
       };
-      if (f.enabled === !1) {
-        i.DefaultLogger.Warn(`The middleware ${e} has been loaded but is disabled.`);
+      if (mergedOptions.enabled === false) {
+        koatty_logger.DefaultLogger.Warn(`The middleware ${key} has been loaded but is disabled.`);
         continue;
       }
-      const g = await a.run(f, this.app);
-      if (r.Helper.isFunction(g)) {
-        let t = g;
-        if (f.protocol) {
-          const a = r.Helper.isArray(f.protocol) ? f.protocol : [ f.protocol ];
-          i.DefaultLogger.Log("Koatty", "", `Middleware ${e} limited to protocols: ${a.join(", ")}`);
-          t = o.protocolMiddleware(a, g);
+      const result = await handle.run(mergedOptions, this.app);
+      if (koatty_lib.Helper.isFunction(result)) {
+        let middleware = result;
+        if (mergedOptions.protocol) {
+          const protocols = koatty_lib.Helper.isArray(mergedOptions.protocol) ? mergedOptions.protocol : [
+            mergedOptions.protocol
+          ];
+          koatty_logger.DefaultLogger.Log("Koatty", "", `Middleware ${key} limited to protocols: ${protocols.join(", ")}`);
+          middleware = koatty_core.protocolMiddleware(protocols, result);
+        }
+        if (middleware.length < 3) {
+          this.app.use(middleware);
+        } else {
+          this.app.useExp(middleware);
         }
-        if (t.length < 3) this.app.use(t); else this.app.useExp(t);
       }
     }
   }
+  /**
+  * Load and register controller classes from IOC container.
+  * Each controller must implement the IController interface.
+  * 
+  * @returns {Promise<string[]>} A promise that resolves to an array of controller IDs.
+  * @protected
+  * @throws {Error} If a controller does not implement the IController interface.
+  */
   async LoadControllers() {
-    const e = t.IOC.listClass("CONTROLLER");
-    const a = [];
-    e.forEach(e => {
-      var n;
-      e.id = ((n = e.id) !== null && n !== void 0 ? n : "").replace("CONTROLLER:", "");
-      if (e.id && r.Helper.isClass(e.target)) {
-        i.DefaultLogger.Debug(`Load controller: ${e.id}`);
-        t.IOC.reg(e.id, e.target, {
+    const controllerList = koatty_container.IOC.listClass("CONTROLLER");
+    const controllers = [];
+    controllerList.forEach((item) => {
+      item.id = (item.id ?? "").replace("CONTROLLER:", "");
+      if (item.id && koatty_lib.Helper.isClass(item.target)) {
+        koatty_logger.DefaultLogger.Debug(`Load controller: ${item.id}`);
+        koatty_container.IOC.reg(item.id, item.target, {
           scope: "Prototype",
           type: "CONTROLLER",
           args: []
         });
-        const r = t.IOC.getInsByClass(e.target);
-        if (!o.implementsControllerInterface(r)) throw Error(`The controller ${e.id} must implements interface 'IController'.`);
-        a.push(e.id);
+        const ctl = koatty_container.IOC.getInsByClass(item.target);
+        if (!koatty_core.implementsControllerInterface(ctl)) {
+          throw Error(`The controller ${item.id} must implements interface 'IController'.`);
+        }
+        controllers.push(item.id);
       }
     });
-    this.app.setMetaData("_controllers", a);
-    return a;
+    this.app.setMetaData("_controllers", controllers);
+    return controllers;
   }
+  /**
+  * Load and register service components into IOC container.
+  * Each service must implement the IService interface.
+  * Services are registered with singleton scope.
+  * 
+  * @protected
+  * @returns {Promise<void>}
+  * @throws {Error} When service does not implement IService interface
+  */
   async LoadServices() {
-    var e;
-    const a = t.IOC.listClass("SERVICE");
-    for (const n of a) {
-      n.id = ((e = n.id) !== null && e !== void 0 ? e : "").replace("SERVICE:", "");
-      if (n.id && r.Helper.isClass(n.target)) {
-        i.DefaultLogger.Debug(`Load service: ${n.id}`);
-        t.IOC.reg(n.id, n.target, {
+    const serviceList = koatty_container.IOC.listClass("SERVICE");
+    for (const item of serviceList) {
+      item.id = (item.id ?? "").replace("SERVICE:", "");
+      if (item.id && koatty_lib.Helper.isClass(item.target)) {
+        koatty_logger.DefaultLogger.Debug(`Load service: ${item.id}`);
+        koatty_container.IOC.reg(item.id, item.target, {
           scope: "Singleton",
           type: "SERVICE",
           args: []
         });
-        const e = t.IOC.getInsByClass(n.target);
-        if (!o.implementsServiceInterface(e)) throw Error(`The service ${n.id} must implements interface 'IService'.`);
+        const ctl = koatty_container.IOC.getInsByClass(item.target);
+        if (!koatty_core.implementsServiceInterface(ctl)) {
+          throw Error(`The service ${item.id} must implements interface 'IService'.`);
+        }
       }
     }
   }
-  async LoadComponents(e) {
-    var a, n;
-    const s = t.IOC.listClass("COMPONENT");
-    s.forEach(e => {
-      var a;
-      e.id = ((a = e.id) !== null && a !== void 0 ? a : "").replace("COMPONENT:", "");
-      if (r.Helper.isClass(e.target)) {
-        t.IOC.reg(e.id, e.target, {
+  /**
+  * Load and initialize components, plugins and aspects.
+  * Components with suffix 'Plugin' must implement IPlugin interface.
+  * Components with suffix 'Aspect' must implement IAspect interface.
+  * Plugins are loaded based on configuration and executed synchronously.
+  * 
+  * @protected
+  * @returns {Promise<void>}
+  * @throws {Error} When plugin/aspect doesn't implement required interface
+  * @throws {Error} When plugin loading fails
+  */
+  async LoadComponents(componentManager) {
+    const componentList = koatty_container.IOC.listClass("COMPONENT");
+    componentList.forEach((item) => {
+      item.id = (item.id ?? "").replace("COMPONENT:", "");
+      if (koatty_lib.Helper.isClass(item.target)) {
+        koatty_container.IOC.reg(item.id, item.target, {
           scope: "Singleton",
           type: "COMPONENT",
           args: []
         });
-        if (e.id && e.id.endsWith("Aspect")) {
-          const a = t.IOC.getInsByClass(e.target);
-          if (!o.implementsAspectInterface(a)) throw Error(`The aspect ${e.id} must implements interface 'IAspect'.`);
+        if (item.id && item.id.endsWith("Aspect")) {
+          const ctl = koatty_container.IOC.getInsByClass(item.target);
+          if (!koatty_core.implementsAspectInterface(ctl)) {
+            throw Error(`The aspect ${item.id} must implements interface 'IAspect'.`);
+          }
         }
       }
     });
-    if (e) await e.loadUserComponents(); else {
-      i.DefaultLogger.Warn("Loading plugins in legacy mode");
-      let e = this.app.config(void 0, "plugin");
-      if (r.Helper.isEmpty(e)) e = {
-        config: {},
-        list: []
-      };
-      const o = (a = e.list) !== null && a !== void 0 ? a : [];
-      for (const a of o) {
-        const o = t.IOC.get(a, "COMPONENT");
-        if (!o) throw Error(`Plugin ${a} load error.`);
-        if (!r.Helper.isFunction(o.run)) throw Error(`Plugin ${a} must implements interface 'IPlugin'.`);
-        if (e.config[a] === !1) {
-          i.DefaultLogger.Warn(`Plugin ${a} already loaded but not effective.`);
+    if (componentManager) {
+      await componentManager.loadUserComponents();
+    } else {
+      koatty_logger.DefaultLogger.Warn("Loading plugins in legacy mode");
+      let pluginsConf = this.app.config(void 0, "plugin");
+      if (koatty_lib.Helper.isEmpty(pluginsConf)) {
+        pluginsConf = {
+          config: {},
+          list: []
+        };
+      }
+      const pluginConfList = pluginsConf.list ?? [];
+      for (const key of pluginConfList) {
+        const handle = koatty_container.IOC.get(key, "COMPONENT");
+        if (!handle) {
+          throw Error(`Plugin ${key} load error.`);
+        }
+        if (!koatty_lib.Helper.isFunction(handle.run)) {
+          throw Error(`Plugin ${key} must implements interface 'IPlugin'.`);
+        }
+        if (pluginsConf.config[key] === false) {
+          koatty_logger.DefaultLogger.Warn(`Plugin ${key} already loaded but not effective.`);
           continue;
         }
-        await o.run((n = e.config[a]) !== null && n !== void 0 ? n : {}, this.app);
+        await handle.run(pluginsConf.config[key] ?? {}, this.app);
       }
     }
   }
-}
-
-/*
- * @Description: framework bootstrap
- * @Usage:
- * @Author: richen
- * @Date: 2021-12-09 21:56:32
- * @LastEditTime: 2025-01-14 16:11:21
- * @License: BSD (3-Clause)
- * @Copyright (c): <richenlin(at)gmail.com>
- */ function D(e) {
-  return async t => {
-    if (!(t.prototype instanceof o.Koatty)) throw new Error(`class ${t.name} does not inherit from Koatty`);
-    return await b(t, e, !0);
+};
+function ExecBootStrap(bootFunc) {
+  return async (target) => {
+    if (!(target.prototype instanceof koatty_core.Koatty)) {
+      throw new Error(`class ${target.name} does not inherit from Koatty`);
+    }
+    return await executeBootstrap(target, bootFunc, true);
   };
 }
-
-const b = async function(e, a, n = !1) {
+__name(ExecBootStrap, "ExecBootStrap");
+var executeBootstrap = /* @__PURE__ */ __name(async function(target, bootFunc, isInitiative = false) {
   if (process.env.NODE_DEBUG) {
-    const e = process.env.NODE_DEBUG.split(",").filter(e => !e.includes("winston")).join(",");
-    process.env.NODE_DEBUG = e;
+    const debugModules = process.env.NODE_DEBUG.split(",").filter((m) => !m.includes("winston")).join(",");
+    process.env.NODE_DEBUG = debugModules;
   }
-  h();
-  const s = C();
-  if (!n && s) return;
-  const l = Reflect.construct(e, []);
-  if (s) {
-    l.silent = !0;
-    i.DefaultLogger.enable(!1);
+  checkRuntime();
+  const isUTRuntime = checkUTRuntime();
+  if (!isInitiative && isUTRuntime) {
+    return;
+  }
+  const app = Reflect.construct(target, []);
+  if (isUTRuntime) {
+    app.silent = true;
+    koatty_logger.DefaultLogger.enable(false);
   }
   try {
-    if (!l.silent) console.log(w);
-    if (!(l instanceof o.Koatty)) throw new Error(`class ${e.name} does not inherit from Koatty`);
-    Loader.initialize(l);
-    if (r.Helper.isFunction(a)) {
-      i.DefaultLogger.Log("Koatty", "", "Execute bootFunc ...");
-      await a(l);
+    if (!app.silent) console.log(LOGO);
+    if (!(app instanceof koatty_core.Koatty)) {
+      throw new Error(`class ${target.name} does not inherit from Koatty`);
+    }
+    Loader.initialize(app);
+    if (koatty_lib.Helper.isFunction(bootFunc)) {
+      koatty_logger.DefaultLogger.Log("Koatty", "", "Execute bootFunc ...");
+      await bootFunc(app);
     }
-    t.IOC.setApp(l);
-    i.DefaultLogger.Log("Koatty", "", "ComponentScan ...");
-    Loader.CheckAllComponents(l, e);
-    await Loader.LoadAllComponents(l, e);
-    if (!s) l.listen(I);
-    return l;
-  } catch (e) {
-    i.DefaultLogger.Fatal(e);
+    koatty_container.IOC.setApp(app);
+    koatty_logger.DefaultLogger.Log("Koatty", "", "ComponentScan ...");
+    Loader.CheckAllComponents(app, target);
+    await Loader.LoadAllComponents(app, target);
+    if (!isUTRuntime) {
+      app.listen(listenCallback);
+    }
+    return app;
+  } catch (err) {
+    koatty_logger.DefaultLogger.Fatal(err);
   }
-};
-
-const I = e => {
-  i.DefaultLogger.Log("Koatty", "", "====================================");
-  i.DefaultLogger.Log("Koatty", "", `Nodejs Version: ${process.version}`);
-  i.DefaultLogger.Log("Koatty", "", `Koatty Version: v${L}`);
-  i.DefaultLogger.Log("Koatty", "", `App Environment: ${e.env}`);
-  if (e.appDebug) i.DefaultLogger.Warn(`Running in debug mode.`);
-  i.DefaultLogger.Log("Koatty", "", "====================================");
-  o.asyncEvent(e, o.AppEvent.appStart);
-};
-
-function P(e) {
-  return function(a) {
-    if (!(a.prototype instanceof o.Koatty)) throw new Error(`class does not inherit from Koatty`);
-    t.IOC.saveClass("COMPONENT", a, "KOATTY_APP");
-    D(e)(a);
-    return a;
+}, "executeBootstrap");
+var listenCallback = /* @__PURE__ */ __name((app) => {
+  koatty_logger.DefaultLogger.Log("Koatty", "", "====================================");
+  koatty_logger.DefaultLogger.Log("Koatty", "", `Nodejs Version: ${process.version}`);
+  koatty_logger.DefaultLogger.Log("Koatty", "", `Koatty Version: v${KOATTY_VERSION}`);
+  koatty_logger.DefaultLogger.Log("Koatty", "", `App Environment: ${app.env}`);
+  if (app.appDebug) koatty_logger.DefaultLogger.Warn(`Running in debug mode.`);
+  koatty_logger.DefaultLogger.Log("Koatty", "", "====================================");
+  koatty_core.asyncEvent(app, koatty_core.AppEvent.appStart);
+}, "listenCallback");
+function Bootstrap(bootFunc) {
+  return function(target) {
+    if (!(target.prototype instanceof koatty_core.Koatty)) {
+      throw new Error(`class does not inherit from Koatty`);
+    }
+    koatty_container.IOC.saveClass("COMPONENT", target, "KOATTY_APP");
+    ExecBootStrap(bootFunc)(target);
+    return target;
   };
 }
-
-function A(e) {
-  return a => {
-    if (!(a.prototype instanceof o.Koatty)) throw new Error(`class does not inherit from Koatty`);
-    e = e !== null && e !== void 0 ? e : "";
-    t.IOC.saveClassMetadata(t.TAGGED_CLS, E, e, a);
+__name(Bootstrap, "Bootstrap");
+function ComponentScan(scanPath) {
+  return (target) => {
+    if (!(target.prototype instanceof koatty_core.Koatty)) {
+      throw new Error(`class does not inherit from Koatty`);
+    }
+    scanPath = scanPath ?? "";
+    koatty_container.IOC.saveClassMetadata(koatty_container.TAGGED_CLS, COMPONENT_SCAN, scanPath, target);
   };
 }
-
-function M(e) {
-  return a => {
-    if (!(a.prototype instanceof o.Koatty)) throw new Error(`class does not inherit from Koatty`);
-    e = e !== null && e !== void 0 ? e : "";
-    t.IOC.saveClassMetadata(t.TAGGED_CLS, O, e, a);
+__name(ComponentScan, "ComponentScan");
+function ConfigurationScan(scanPath) {
+  return (target) => {
+    if (!(target.prototype instanceof koatty_core.Koatty)) {
+      throw new Error(`class does not inherit from Koatty`);
+    }
+    scanPath = scanPath ?? "";
+    koatty_container.IOC.saveClassMetadata(koatty_container.TAGGED_CLS, CONFIGURATION_SCAN, scanPath, target);
   };
 }
+__name(ConfigurationScan, "ConfigurationScan");
+/**
+ * Decorator for Koatty framework
+ * @author richen
+ * @copyright Copyright (c) - <richenlin(at)gmail.com>
+ * @license BSD (3-Clause)
+ * @version 2026-02-03 10:00:00
+ */
 
 Object.defineProperty(exports, "Config", {
-  enumerable: !0,
-  get: function() {
-    return e.Config;
-  }
+  enumerable: true,
+  get: function () { return koatty_config.Config; }
 });
-
 Object.defineProperty(exports, "Helper", {
-  enumerable: !0,
-  get: function() {
-    return r.Helper;
-  }
+  enumerable: true,
+  get: function () { return koatty_lib.Helper; }
 });
-
 Object.defineProperty(exports, "Log", {
-  enumerable: !0,
-  get: function() {
-    return i.Log;
-  }
+  enumerable: true,
+  get: function () { return koatty_logger.Log; }
+});
+Object.defineProperty(exports, "LogLevelType", {
+  enumerable: true,
+  get: function () { return koatty_logger.LogLevelType; }
 });
-
 Object.defineProperty(exports, "Logger", {
-  enumerable: !0,
-  get: function() {
-    return i.DefaultLogger;
-  }
+  enumerable: true,
+  get: function () { return koatty_logger.DefaultLogger; }
 });
-
-exports.Bootstrap = P;
-
-exports.ComponentScan = A;
-
-exports.ConfigurationScan = M;
-
-exports.ExecBootStrap = D;
-
-Object.keys(t).forEach(function(e) {
-  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
-    enumerable: !0,
-    get: function() {
-      return t[e];
-    }
+exports.Bootstrap = Bootstrap;
+exports.ComponentScan = ComponentScan;
+exports.ConfigurationScan = ConfigurationScan;
+exports.ExecBootStrap = ExecBootStrap;
+Object.keys(koatty_container).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return koatty_container[k]; }
   });
 });
-
-Object.keys(o).forEach(function(e) {
-  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
-    enumerable: !0,
-    get: function() {
-      return o[e];
-    }
+Object.keys(koatty_core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return koatty_core[k]; }
   });
 });
-
-Object.keys(a).forEach(function(e) {
-  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
-    enumerable: !0,
-    get: function() {
-      return a[e];
-    }
+Object.keys(koatty_exception).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return koatty_exception[k]; }
   });
 });
-
-Object.keys(n).forEach(function(e) {
-  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
-    enumerable: !0,
-    get: function() {
-      return n[e];
-    }
+Object.keys(koatty_router).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return koatty_router[k]; }
   });
 });
-
-Object.keys(s).forEach(function(e) {
-  if (e !== "default" && !Object.prototype.hasOwnProperty.call(exports, e)) Object.defineProperty(exports, e, {
-    enumerable: !0,
-    get: function() {
-      return s[e];
-    }
+Object.keys(koatty_serve).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return koatty_serve[k]; }
   });
 });
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map