@yumerijs/core 1.1.2 → 1.2.0

package/dist/core.js

@@ -32,9 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Core = void 0;
 /**
@@ -48,7 +45,8 @@ const path = __importStar(require("path"));
 const config_1 = require("./config");
 const logger_1 = require("./logger");
 const command_1 = require("./command");
-const chokidar_1 = __importDefault(require("chokidar"));
+const chokidar = __importStar(require("chokidar"));
+const route_1 = require("./route");
 const context_1 = require("./context");
 class Core {
     plugins = {};
@@ -57,18 +55,46 @@ class Core {
     eventListeners = {};
     components = {};
     commands = {};
+    routes = {};
     pluginLoader;
     logger = new logger_1.Logger('core');
     providedComponents = {};
     pluginModules = {};
     configPath = '';
     globalMiddlewares = {};
+    /**
+     * @deprecated 命令与插件对应关系
+     */
     cmdtoplu = {};
+    /**
+     * 路由与插件对应关系
+     */
+    routetoplu = {};
+    /**
+     * 组件与插件对应关系
+     */
     comtoplu = {};
+    /**
+     * 事件监听器与插件对应关系
+     */
     evttoplu = {};
+    /**
+     * 中间件与插件对应关系
+     */
     mdwtoplu = {};
     plftoplu = {};
+    /**
+     * 插件状态
+     */
     pluginStatus = {};
+    /**
+     * 插件监听器
+     */
+    pluginWatchers = {};
+    /**
+     * 初始化核心
+     * @param pluginLoader 插件加载器
+     */
     constructor(pluginLoader) {
         this.pluginLoader = pluginLoader;
     }
@@ -96,7 +122,7 @@ class Core {
      * @param configPath 配置文件的路径
      */
     watchConfig(configPath) {
-        const watcher = chokidar_1.default.watch(configPath, {
+        const watcher = chokidar.watch(configPath, {
             persistent: true,
             ignoreInitial: true,
             awaitWriteFinish: {
@@ -143,6 +169,7 @@ class Core {
     }
     /**
      * 加载所有在配置文件中启用的插件
+     * @returns Promise<void>
      */
     async loadPlugins() {
         if (!this.config || typeof this.config.plugins !== 'object' || this.config.plugins === null) {
@@ -162,6 +189,13 @@ class Core {
             }
         }
         const enabledPlugins = allPluginNames.filter(name => !name.startsWith('~'));
+        // 卸载配置中已禁用或移除的已加载插件
+        const currentlyLoaded = Object.keys(this.plugins);
+        for (const loadedName of currentlyLoaded) {
+            if (!enabledPlugins.includes(loadedName)) {
+                await this.unloadPlugin(loadedName);
+            }
+        }
         if (enabledPlugins.length === 0) {
             this.logger.info('No enabled plugins found in configuration.');
             return;
@@ -189,23 +223,20 @@ class Core {
         if (pendingPlugins.length > 0) {
             // this.logger.warn('Some plugins could not be loaded due to unresolved dependencies:', pendingPlugins);
         }
-        if (process.env.NODE_ENV === 'development') {
-            this.watchPlugins(this);
-        }
     }
     /**
-     * 导出的函数：加载单个插件
+     * 加载单个插件
      * @param pluginName 要加载的插件名
      * @param triggerPendingCheck 是否在加载后触发对其他待定插件的检查，默认为 true
      * @returns Promise<boolean> 是否加载成功
      */
-    async loadSinglePlugin(pluginName, triggerPendingCheck = true) {
+    async loadSinglePlugin(pluginName, triggerPendingCheck = true, onlypending = false) {
         // 如果插件不存在于状态记录中（例如，动态添加），则设为 PENDING
         if (!this.pluginStatus[pluginName]) {
             this.pluginStatus[pluginName] = "pending" /* PluginStatus.PENDING */;
         }
         // 只有 PENDING 状态的插件才能被加载
-        if (this.pluginStatus[pluginName] !== "pending" /* PluginStatus.PENDING */) {
+        if (this.pluginStatus[pluginName] !== "pending" /* PluginStatus.PENDING */ && onlypending) {
             // this.logger.info(`Plugin "${pluginName}" is not in a pending state (current: ${this.pluginStatus[pluginName]}). Skipping load.`);
             return false;
         }
@@ -223,8 +254,8 @@ class Core {
             // 依赖满足，开始加载
             this.plugins[pluginName] = pluginInstance;
             if (pluginInstance.apply) {
+                this.pluginLoader.logger.info(`Apply plugin "${pluginName}"`);
                 await pluginInstance.apply(new context_1.Context(this, pluginName), await this.getPluginConfig(pluginName));
-                this.pluginLoader.logger.info(`Applied plugin "${pluginName}"`);
             }
             // 注册提供的组件
             if (pluginInstance.provide) {
@@ -238,11 +269,34 @@ class Core {
                 }
             }
             this.pluginStatus[pluginName] = "enabled" /* PluginStatus.ENABLED */; // 更新状态为已启用
-            // this.logger.info(`Plugin "${pluginName}" loaded successfully.`);
             // 加载成功后，检查是否可以加载其他等待中的插件
             if (triggerPendingCheck) {
                 await this._loadPendingPlugins();
             }
+            // In development mode, watch the plugin for changes.
+            if (process.env.NODE_ENV === 'development') {
+                let pluginPathToWatch = null;
+                try {
+                    const pkgJsonPath = require.resolve(`${pluginName}/package.json`);
+                    pluginPathToWatch = path.dirname(pkgJsonPath);
+                }
+                catch (e) {
+                    const localPluginPath = path.resolve(process.cwd(), pluginName);
+                    const localPluginPathInPlugins = path.resolve(process.cwd(), 'plugins', pluginName);
+                    if (fs.existsSync(localPluginPath)) {
+                        pluginPathToWatch = localPluginPath;
+                    }
+                    else if (fs.existsSync(localPluginPathInPlugins)) {
+                        pluginPathToWatch = localPluginPathInPlugins;
+                    }
+                }
+                if (pluginPathToWatch) {
+                    this.watchPlugin(pluginName, pluginPathToWatch);
+                }
+                else {
+                    this.logger.warn(`Could not resolve path for plugin ${pluginName} to watch for changes.`);
+                }
+            }
             return true;
         }
         catch (err) {
@@ -252,7 +306,8 @@ class Core {
         }
     }
     /**
-     * 内部函数：尝试加载所有处于 PENDING 状态的插件
+     * 尝试加载所有处于 PENDING 状态的插件
+     * @returns Promise<void>
      */
     async _loadPendingPlugins() {
         const pendingPlugins = Object.keys(this.pluginStatus).filter(p => this.pluginStatus[p] === "pending" /* PluginStatus.PENDING */);
@@ -267,7 +322,7 @@ class Core {
      * 卸载插件，并递归卸载依赖于它的其他插件
      * @param pluginNameToUnload 要卸载的插件名
      */
-    async unloadPlugin(pluginNameToUnload) {
+    async unloadPlugin(pluginNameToUnload, ispending = false) {
         // 1. 找出所有直接或间接依赖于此插件的插件
         const dependents = [];
         const pluginsToCheck = [pluginNameToUnload];
@@ -291,18 +346,19 @@ class Core {
         }
         // 2. 卸载所有依赖者
         for (const dependentName of dependents) {
-            await this._unloadSinglePlugin(dependentName);
+            await this.unloadPlugin(dependentName, true);
         }
         // 3. 最后卸载目标插件
-        await this._unloadSinglePlugin(pluginNameToUnload);
+        await this._unloadSinglePlugin(pluginNameToUnload, ispending);
         // 4. 卸载完成后，尝试重新加载处于 PENDING 状态的插件
         // await this._loadPendingPlugins();
     }
     /**
-     * 内部函数：执行单个插件的卸载逻辑
+     * 执行单个插件的卸载逻辑
      * @param pluginName 插件名
+     * @param ispending 是否处于 PENDING 状态
      */
-    async _unloadSinglePlugin(pluginName) {
+    async _unloadSinglePlugin(pluginName, ispending = false) {
         if (this.pluginStatus[pluginName] !== "enabled" /* PluginStatus.ENABLED */) {
             return; // 只卸载已启用的插件
         }
@@ -316,11 +372,13 @@ class Core {
             this.unregall(pluginName); // 清理该插件注册的所有内容
             delete this.plugins[pluginName];
             delete this.pluginModules[pluginName];
-            // 更新状态为 PENDING，因为它的配置仍然是启用的
-            // 如果它被其他插件依赖，当那个插件被卸载时，它也会被重新评估
-            this.pluginStatus[pluginName] = "pending" /* PluginStatus.PENDING */;
+            this.pluginStatus[pluginName] = ispending ? "pending" /* PluginStatus.PENDING */ : "disabled" /* PluginStatus.DISABLED */;
+            // Stop watching the plugin directory
+            if (this.pluginWatchers[pluginName]) {
+                this.pluginWatchers[pluginName].close();
+                delete this.pluginWatchers[pluginName];
+            }
             this.emit('plugin-unloaded', pluginName);
-            // this.logger.info(`Plugin "${pluginName}" unloaded.`);
         }
         catch (error) {
             this.logger.error(`Failed to unload plugin "${pluginName}":`, error);
@@ -346,14 +404,17 @@ class Core {
         }
     }
     /**
-     * 监听插件文件变化，实现热更新
-     * @param core Core 实例
-     * @param pluginsDir 插件目录，默认为 'plugins'
+     * 监听插件文件变化
+     * @param pluginName 插件名称
+     * @param pluginPath 插件路径
      */
-    watchPlugins(core, pluginsDir = 'plugins') {
+    watchPlugin(pluginName, pluginPath) {
+        if (this.pluginWatchers[pluginName]) {
+            return; // Already watching
+        }
         const logger = new logger_1.Logger('hmr');
-        const watcher = chokidar_1.default.watch(pluginsDir, {
-            ignored: /(^|[/\\])\../,
+        const watcher = chokidar.watch(pluginPath, {
+            ignored: /(^|[\/])\../,
             persistent: true,
             ignoreInitial: true,
             awaitWriteFinish: {
@@ -361,34 +422,20 @@ class Core {
                 pollInterval: 100,
             },
         });
-        const getPluginNameFromPath = (changePath) => {
-            if (!changePath.endsWith('.ts') && !changePath.endsWith('.js'))
-                return null;
-            const parts = changePath.split(path.sep);
-            return parts.length > 1 ? parts[1] : null;
-        };
         watcher.on('change', async (changePath) => {
-            const pluginName = getPluginNameFromPath(changePath);
-            if (pluginName) {
-                logger.info(`Plugin file changed: ${changePath}`);
-                await core.reloadPlugin(pluginName);
-            }
+            logger.info(`Plugin file changed: ${changePath}`);
+            await this.reloadPlugin(pluginName);
         });
         watcher.on('add', async (changePath) => {
-            const pluginName = getPluginNameFromPath(changePath);
-            if (pluginName) {
-                logger.info(`New plugin file added: ${changePath}`);
-                await core.reloadPlugin(pluginName);
-            }
+            logger.info(`New file added to plugin ${pluginName}: ${changePath}`);
+            await this.reloadPlugin(pluginName);
         });
         watcher.on('unlink', async (changePath) => {
-            const pluginName = getPluginNameFromPath(changePath);
-            if (pluginName) {
-                logger.info(`Plugin file removed: ${changePath}`);
-                await core.unloadPlugin(pluginName);
-            }
+            logger.info(`File removed from plugin ${pluginName}: ${changePath}`);
+            await this.reloadPlugin(pluginName);
         });
-        logger.info(`Watching for plugin changes in ${pluginsDir}`);
+        this.pluginWatchers[pluginName] = watcher;
+        // logger.info(`Watching for changes in plugin: ${pluginName}`);
     }
     /**
      * 注册组件
@@ -459,21 +506,26 @@ class Core {
         return this;
     }
     /**
-     * 注册命令
-     * @param name 命令名称
-     * @returns Command 实例
+     * @deprecated 已更改为路由
      */
     command(name) {
         const command = new command_1.Command(this, name);
         this.commands[name] = command;
         return command;
     }
+    /**
+     * 注册路由
+     * @param path 路由路径
+     * @returns Route 实例
+     */
+    route(path) {
+        const route = new route_1.Route(path);
+        this.routes[path] = route;
+        return route;
+    }
     /**
      * 执行命令
-     * @param name 命令名称
-     * @param session 会话对象
-     * @param args 传递给命令处理函数的参数
-     * @returns 会话对象或 null
+     * @deprecated
      */
     async executeCommand(name, session, ...args) {
         const command = this.commands[name];
@@ -496,6 +548,37 @@ class Core {
         }
         return null;
     }
+    /**
+     * 执行路由
+     * @param pathname 需要匹配的URL
+     * @param session 当前会话
+     * @param queryParams URL参数
+     * @returns 是否匹配成功
+     */
+    async executeRoute(pathname, session, queryParams) {
+        for (const routePath in this.routes) {
+            const route = this.routes[routePath];
+            const result = route.match(pathname);
+            if (result) {
+                const globalMiddlewareList = Object.values(this.globalMiddlewares || {});
+                const routeMiddlewareList = route.middlewares || [];
+                const middlewares = [...globalMiddlewareList, ...routeMiddlewareList];
+                let index = 0;
+                const runner = async () => {
+                    if (index < middlewares.length) {
+                        const middleware = middlewares[index++];
+                        await middleware(session, runner);
+                    }
+                    else {
+                        await route.executeHandler(session, queryParams, result.pathParams);
+                    }
+                };
+                await runner();
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * 注册平台
      * @param platform 平台实例
@@ -517,6 +600,13 @@ class Core {
             delete this.cmdtoplu[cmd];
             delete this.commands[cmd];
         });
+        // 清理 routes
+        Object.keys(this.routetoplu)
+            .filter(path => this.routetoplu[path] === pluginname)
+            .forEach(path => {
+            delete this.routetoplu[path];
+            delete this.routes[path];
+        });
         // 清理 components 和 providedComponents
         Object.keys(this.comtoplu)
             .filter(comp => this.comtoplu[comp] === pluginname)
@@ -525,6 +615,12 @@ class Core {
             delete this.components[comp];
             delete this.providedComponents[comp];
         });
+        // 清理由 provide 声明的组件提供关系
+        Object.keys(this.providedComponents)
+            .filter(prov => this.providedComponents[prov] === pluginname)
+            .forEach(prov => {
+            delete this.providedComponents[prov];
+        });
         // 清理 event listeners
         for (const evt in this.evttoplu) {
             if (this.evttoplu[evt][pluginname]) {
@@ -551,5 +647,19 @@ class Core {
     getCommand(name) {
         return this.commands[name] || null;
     }
+    /**
+     * 获取路由
+     * @param path 匹配路径
+     * @return Route 实例或 false
+     */
+    getRoute(path) {
+        for (const routePath in this.routes) {
+            const route = this.routes[routePath];
+            if (route.match(path)) {
+                return route;
+            }
+        }
+        return false;
+    }
 }
 exports.Core = Core;

package/dist/index.d.ts

@@ -6,6 +6,7 @@
 export * from './core';
 export * from './session';
 export * from './command';
+export * from './route';
 export * from './config';
 export * from './logger';
 export * from './platform';

package/dist/index.js

@@ -22,6 +22,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./core"), exports);
 __exportStar(require("./session"), exports);
 __exportStar(require("./command"), exports);
+__exportStar(require("./route"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./platform"), exports);

package/dist/logger.d.ts

@@ -12,6 +12,7 @@ export declare class Logger {
     static setCore(core: Core): void;
     constructor(title: string);
     private getRandomColor;
+    private getTimestamp;
     private log;
     info(...args: any[]): void;
     warn(...args: any[]): void;

package/dist/logger.js

@@ -9,7 +9,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
-const ansi_colors_1 = __importDefault(require("ansi-colors")); // 引入 ansi-colors
+const picocolors_1 = __importDefault(require("picocolors")); // 轻量颜色库
 class Logger {
     title;
     titleColor;
@@ -27,126 +27,26 @@ class Logger {
         this.titleColor = this.getRandomColor();
     }
     getRandomColor() {
-        const availableColors = [ansi_colors_1.default.red, ansi_colors_1.default.green, ansi_colors_1.default.yellow, ansi_colors_1.default.blue, ansi_colors_1.default.magenta, ansi_colors_1.default.cyan, ansi_colors_1.default.white, ansi_colors_1.default.gray];
+        const availableColors = [
+            picocolors_1.default.red, picocolors_1.default.green, picocolors_1.default.yellow, picocolors_1.default.blue,
+            picocolors_1.default.magenta, picocolors_1.default.cyan, picocolors_1.default.white, picocolors_1.default.gray
+        ];
         const randomIndex = Math.floor(Math.random() * availableColors.length);
         return availableColors[randomIndex];
     }
-    log(level, ...args) {
+    getTimestamp() {
         const now = new Date();
-        const timestamp = `${now.getFullYear()}/${String(now.getMonth() + 1).padStart(2, '0')}/${String(now.getDate()).padStart(2, '0')} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
-        console.log(`${timestamp} [${level}] ${this.titleColor(this.title)} `, ...args);
-        Logger.coreInstance?.emit('log', { level, message: args.join(' ') });
-    }
-    info(...args) {
-        this.log('I', ...args);
-    }
-    warn(...args) {
-        this.log('W', ...args);
+        return `${now.getFullYear()}/${String(now.getMonth() + 1).padStart(2, '0')}/${String(now.getDate()).padStart(2, '0')} ` +
+            `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}`;
     }
-    error(...args) {
-        this.log('E', ...args);
+    log(level, ...args) {
+        const levelColor = level === 'E' ? picocolors_1.default.red : level === 'W' ? picocolors_1.default.yellow : picocolors_1.default.cyan;
+        const timestamp = this.getTimestamp();
+        console.log(`${picocolors_1.default.gray(timestamp)} [${levelColor(level)}] ${this.titleColor(this.title)}`, ...args);
+        Logger.coreInstance?.emit('log', { level, message: args.join(' ') });
     }
+    info(...args) { this.log('I', ...args); }
+    warn(...args) { this.log('W', ...args); }
+    error(...args) { this.log('E', ...args); }
 }
 exports.Logger = Logger;
-function stringifyDebug(value, seen = new WeakSet(), depth = 0, indent = 2, maxDepth = 5) {
-    const pad = ' '.repeat(depth * indent);
-    const nextPad = ' '.repeat((depth + 1) * indent);
-    // --- 1. 处理基本类型和 null ---
-    if (value === null) {
-        return 'null';
-    }
-    const type = typeof value;
-    if (type === 'string') {
-        // 确保 value 是字符串，并正确转义内部单引号
-        return `'${value.replace(/'/g, "\\'")}'`;
-    }
-    if (type === 'number' || type === 'boolean') {
-        return String(value);
-    }
-    if (type === 'undefined') {
-        return 'undefined';
-    }
-    if (type === 'symbol') {
-        return value.toString();
-    }
-    if (type === 'function') {
-        // 类型断言，确保可以访问函数的 name 属性
-        return `[Function: ${value.name || '(anonymous)'}]`;
-    }
-    if (type === 'bigint') {
-        // BigInt 的特殊表示，确保 value 是 BigInt 类型
-        return `${String(value)}n`;
-    }
-    // At this point, 'value' must be a non-primitive object type (object, array, Map, Set, Date, RegExp, custom class)
-    // --- 2. 处理简单的内置对象 (它们不会有循环引用问题) ---
-    if (value instanceof RegExp) {
-        return value.toString();
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    // --- 3. 深度限制检查 ---
-    // 此时 value 确定是一个可以被 seen WeakSet 存储的对象
-    if (depth >= maxDepth) {
-        return '[Object]';
-    }
-    // --- 4. 循环引用检测 ---
-    // 将当前对象添加到 seen Set，以便在后续递归中检测循环引用
-    // 这里需要断言 value 是一个 object 类型，因为 WeakSet 只能存储对象
-    if (seen.has(value)) {
-        return '[Circular]';
-    }
-    seen.add(value); // 添加到已访问集合
-    // --- 5. 处理复杂内置对象 (Array, Map, Set) ---
-    if (Array.isArray(value)) {
-        // 在这一分支中，TypeScript 已经把 value 缩小为 unknown[] 类型
-        if (value.length === 0)
-            return '[]';
-        const elements = value.map(el => stringifyDebug(el, seen, depth + 1, indent, maxDepth));
-        return `[\n${nextPad}${elements.join(`,\n${nextPad}`)}\n${pad}]`;
-    }
-    if (value instanceof Map) {
-        // 在这一分支中，TypeScript 已经把 value 缩小为 Map<unknown, unknown> 类型
-        if (value.size === 0)
-            return 'Map(0) {}';
-        const entries = Array.from(value.entries()).map(([k, v]) => `${stringifyDebug(k, seen, depth + 1, indent, maxDepth)} => ${stringifyDebug(v, seen, depth + 1, indent, maxDepth)}`);
-        return `Map(${value.size}) {\n${nextPad}${entries.join(`,\n${nextPad}`)}\n${pad}}`;
-    }
-    if (value instanceof Set) {
-        // 在这一分支中，TypeScript 已经把 value 缩小为 Set<unknown> 类型
-        if (value.size === 0)
-            return 'Set(0) {}';
-        const elements = Array.from(value.values()).map(el => stringifyDebug(el, seen, depth + 1, indent, maxDepth));
-        return `Set(${value.size}) {\n${nextPad}${elements.join(`,\n${nextPad}`)}\n${pad}}`;
-    }
-    // --- 6. 处理普通对象和自定义类的实例 ---
-    // 此时，value 确定是一个对象 (除了上面已处理的 Array, Map, Set, Date, RegExp, primitive, null)
-    // 并且它已经添加到了 seen 集合
-    const keys = Object.keys(value); // 将 value 断言为 object，确保 Object.keys 可以接受
-    // 获取构造函数名（如果不是普通的 Object）
-    let constructorName = '';
-    // 同样，确保 value 被视为 object 以访问 constructor 属性
-    if (value.constructor && value.constructor.name && value.constructor.name !== 'Object') {
-        constructorName = `${value.constructor.name} `;
-    }
-    if (keys.length === 0) {
-        return `${constructorName}{}`; // 空对象/空类实例
-    }
-    const properties = keys.map(key => {
-        // 将 value 断言为带有索引签名的 Record，以便可以通过字符串键访问属性
-        const propValue = value[key];
-        return `${nextPad}${normalizeObjectKey(key)}: ${stringifyDebug(propValue, seen, depth + 1, indent, maxDepth)}`;
-    });
-    return `${constructorName}{\n${properties.join(',\n')}\n${pad}}`;
-}
-// 辅助函数：格式化对象键名，确保它在字面量中是有效的
-function normalizeObjectKey(key) {
-    // 检查 key 是否是有效的 JavaScript 标识符，且不是保留字
-    // 简化的判断：如果包含非字母数字下划线，或以数字开头，则需要引用。
-    // 更严谨的判断需要解析器级别的检查。这里我们简单处理为如果包含特殊字符或空格就引用。
-    if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) && !['null', 'undefined', 'true', 'false'].includes(key)) {
-        return key; // 不需要引用
-    }
-    // 引用并转义内部的单引号
-    return `'${key.replace(/'/g, "\\'")}'`;
-}

package/dist/route.d.ts

@@ -0,0 +1,58 @@
+import { Session } from './session';
+import { Middleware } from './middleware';
+export type RouteHandler = (session: Session, queryParams: URLSearchParams, ...pathParams: string[]) => Promise<void> | void;
+/**
+ * Route class using segment-based matching (no fragile capture-group-index mapping).
+ * Behavior matches the SimpleRouter in the webpage:
+ * - pathname and pattern are split on '/'
+ * - supports :param (single required), :param? (single optional), :param+ (one or more segments),
+ *   :param* (zero or more segments)
+ * - honors "no trailing slash" expectation (we normalize input)
+ */
+export declare class Route {
+    path: string;
+    private segments;
+    private paramsInfo;
+    private handler;
+    middlewares: Middleware[];
+    allowedMethods: string[];
+    /**
+     * 创建路由
+     * @param path 路由路径
+     */
+    constructor(path: string);
+    /**
+     * 设置路由处理器
+     * @param handler 路由处理器
+     * @returns this
+     */
+    action(handler: RouteHandler): this;
+    /**
+     * 挂载中间件
+     * @param middleware 中间件
+     * @returns this
+     */
+    use(middleware: Middleware): this;
+    /**
+     * 匹配路由
+     * @param pathname 请求路径
+     * @returns 匹配结果
+     */
+    match(pathname: string): {
+        params: Record<string, string | undefined>;
+        pathParams: string[];
+    } | null;
+    /**
+     * 执行路由处理器
+     * @param session 会话对象
+     * @param params 查询参数
+     * @param pathParams 路由参数
+     */
+    executeHandler(session: Session, params: URLSearchParams, pathParams: string[]): Promise<void>;
+    /**
+     * 设置可用方法
+     * @param methods 可用方法
+     * @returns this
+     */
+    methods(...methods: string[]): Route;
+}