@kotori-bot/loader 1.4.2 → 1.5.0-beta.1

package/lib/{loader.d.ts → class/loader.d.ts}

@@ -1,9 +1,9 @@
-import { Container, Symbols } from '@kotori-bot/core';
+import { Container, Symbols, formatFactory } from '@kotori-bot/core';
 import Logger from '@kotori-bot/logger';
 import Runner from './runner';
-import Server from './service/server';
-import type Database from './service/database';
-import File from './service/file';
+import Server from '../service/server';
+import type Database from '../service/database';
+import File from '../service/file';
 declare module '@kotori-bot/core' {
     interface Context {
         readonly baseDir: Runner['baseDir'];
@@ -15,6 +15,8 @@ declare module '@kotori-bot/core' {
         server: Server;
         db: Database;
         file: File;
+        format: ReturnType<typeof formatFactory>;
+        locale: Context['i18n']['locale'];
     }
     interface GlobalConfig {
         dirs: string[];
@@ -22,11 +24,12 @@ declare module '@kotori-bot/core' {
     }
 }
 export declare class Loader extends Container {
-    private ctx;
+    private readonly ctx;
     private loadCount;
     constructor(options?: {
         dir?: string;
         mode?: string;
+        level?: number;
     });
     run(): void;
     private handleError;

package/lib/{loader.js → class/loader.js}

@@ -32,47 +32,44 @@ exports.Loader = void 0;
  * @Blog: https://hotaru.icu
  * @Date: 2023-06-24 15:12:55
  * @LastEditors: Hotaru biyuehuya@gmail.com
- * @LastEditTime: 2024-02-24 19:11:35
+ * @LastEditTime: 2024-05-26 16:45:40
  */
 const core_1 = require("@kotori-bot/core");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const logger_1 = __importDefault(require("@kotori-bot/logger"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const logger_1 = __importStar(require("@kotori-bot/logger"));
 const runner_1 = __importStar(require("./runner"));
-const log_1 = __importDefault(require("./log"));
-const consts_1 = require("./consts");
-const server_1 = __importDefault(require("./service/server"));
-const file_1 = __importDefault(require("./service/file"));
-function getRunnerConfig(file, dir) {
+const log_1 = __importDefault(require("../utils/log"));
+const constants_1 = require("../constants");
+const server_1 = __importDefault(require("../service/server"));
+const file_1 = __importDefault(require("../service/file"));
+function getBaseDir(file, dir) {
     const handle = (root) => {
         const baseDir = {
             root,
-            modules: path_1.default.join(root, 'modules'),
-            data: path_1.default.join(root, 'data'),
-            logs: path_1.default.join(root, 'logs')
+            modules: node_path_1.default.join(root, 'modules'),
+            data: node_path_1.default.join(root, 'data'),
+            logs: node_path_1.default.join(root, 'logs')
         };
         Object.values(baseDir).forEach((val) => {
-            if (!fs_1.default.existsSync(val))
-                fs_1.default.mkdirSync(val);
+            if (!node_fs_1.default.existsSync(val))
+                node_fs_1.default.mkdirSync(val);
         });
         return baseDir;
     };
-    const options = {
-        mode: file === consts_1.DEV_CONFIG_NAME ? 'dev' : 'build'
-    };
     if (dir)
-        return { baseDir: handle(path_1.default.resolve(dir)), options };
-    let root = path_1.default.resolve(__dirname, '..').replace('loader', 'kotori');
+        return handle(node_path_1.default.resolve(dir));
+    let root = node_path_1.default.resolve(__dirname, '..').replace('loader', 'kotori');
     let count = 0;
-    while (!fs_1.default.existsSync(path_1.default.join(root, file))) {
+    while (!node_fs_1.default.existsSync(node_path_1.default.join(root, file))) {
         if (count > 5) {
             logger_1.default.fatal(`cannot find file ${file} `);
             process.exit();
         }
-        root = path_1.default.join(root, '..');
+        root = node_path_1.default.join(root, '..');
         count += 1;
     }
-    return { baseDir: handle(root), options };
+    return handle(root);
 }
 /* eslint consistent-return: 0 */
 function getCoreConfig(file, baseDir) {
@@ -91,7 +88,7 @@ function getCoreConfig(file, baseDir) {
                 .default(core_1.DEFAULT_CORE_CONFIG.plugin)
         })
             .default({ global: Object.assign(core_1.DEFAULT_CORE_CONFIG.global), plugin: core_1.DEFAULT_CORE_CONFIG.plugin })
-            .parse((0, core_1.loadConfig)(path_1.default.join(baseDir.root, file), 'yaml'));
+            .parse((0, core_1.loadConfig)(node_path_1.default.join(baseDir.root, file), 'yaml'));
         return core_1.Tsu.Object({
             adapter: core_1.Tsu.Object({})
                 .index(core_1.Tsu.Object({
@@ -115,13 +112,27 @@ class Loader extends core_1.Container {
     loadCount = 0;
     constructor(options) {
         super();
-        const file = options && options.mode === 'dev' ? consts_1.DEV_CONFIG_NAME : consts_1.BUILD_CONFIG_NAME;
-        const runnerConfig = getRunnerConfig(file, options?.dir);
+        const file = options && options.mode?.startsWith(constants_1.DEV_MODE) ? constants_1.DEV_CONFIG_NAME : constants_1.BUILD_CONFIG_NAME;
+        const runnerConfig = {
+            baseDir: getBaseDir(file, options?.dir),
+            options: { mode: (options?.mode || constants_1.BUILD_MODE) },
+            level: options?.level || options?.mode?.startsWith(constants_1.DEV_MODE) ? logger_1.LoggerLevel.DEBUG : logger_1.LoggerLevel.INFO
+        };
         const ctx = new core_1.Core(getCoreConfig(file, runnerConfig.baseDir));
         ctx.provide('runner', new runner_1.default(ctx, runnerConfig));
         ctx.mixin('runner', ['baseDir', 'options']);
         core_1.Container.setInstance(ctx);
+        ctx.provide('loader-tools', { format: (0, core_1.formatFactory)(ctx.i18n), locale: ctx.i18n.locale.bind(ctx.i18n) });
+        ctx.mixin('loader-tools', ['locale', 'format']);
+        ctx.i18n.use(node_path_1.default.resolve(__dirname, '../../locales'));
         this.ctx = core_1.Container.getInstance();
+        this.ctx.logger.trace(`options:`, options);
+        this.ctx.logger.trace(`runnerConfig:`, runnerConfig);
+        this.ctx.logger.trace(`baseDir:`, this.ctx.baseDir);
+        this.ctx.logger.trace(`options:`, this.ctx.options);
+        this.ctx.logger.trace(`config:`, this.ctx.config);
+        this.ctx.logger.trace(`where:`, __dirname, __filename);
+        this.ctx.logger.trace(`running:`, process.cwd());
     }
     run() {
         (0, log_1.default)(this.ctx.pkg, this.ctx);
@@ -153,42 +164,39 @@ class Loader extends core_1.Container {
         process.on('uncaughtExceptionMonitor', (err) => this.handleError(err, 'sync'));
         process.on('unhandledRejection', (err) => this.handleError(err, 'async'));
         process.on('SIGINT', () => process.exit());
-        this.ctx.logger.debug('run info: develop with debuing...');
+        this.ctx.logger.debug(this.ctx.locale('loader.debug.info'));
     }
     listenMessage() {
         this.ctx.on('connect', (data) => {
-            const { type, mode, normal, address, adapter } = data;
+            const { type, mode, normal, address: addr, adapter } = data;
             let msg;
             if (type === 'connect') {
                 switch (mode) {
                     case 'ws':
-                        msg = `${normal ? 'Connect' : 'Reconnect'} server to ${address}`;
+                        msg = this.ctx.format(`loader.bots.${normal ? 'connect' : 'reconnect'}`, [addr]);
                         break;
                     case 'ws-reverse':
-                        msg = `server ${normal ? 'start' : 'restart'} at ${address}`;
+                        msg = this.ctx.format(`loader.bots.${normal ? 'start' : 'restart'}`, [addr]);
                         break;
                     default:
-                        msg = `ready completed about ${address}`;
+                        msg = this.ctx.format('loader.bots.ready', [addr]);
                 }
             }
             else {
                 switch (mode) {
                     case 'ws':
-                        msg = `disconnect server from ${address}${normal ? '' : ' unexpectedly'}`;
+                        msg = this.ctx.format(`loader.bots.disconnect${normal ? '' : '.error'}`, [addr]);
                         break;
                     case 'ws-reverse':
-                        msg = `server stop at ${address}${normal ? '' : ' unexpectedly'}`;
+                        msg = this.ctx.format(`loader.bots.stop${normal ? '' : '.error'}`, [addr]);
                         break;
                     default:
-                        msg = `dispose completed about ${address}`;
+                        msg = this.ctx.format('loader.bots.dispose', [addr]);
                 }
             }
             adapter.ctx.logger[normal ? 'info' : 'warn'](msg);
         });
-        this.ctx.on('status', (data) => {
-            const { status, adapter } = data;
-            adapter.ctx.logger.info(status);
-        });
+        this.ctx.on('status', ({ status, adapter }) => adapter.ctx.logger.info(status));
         this.ctx.on('ready_module', (data) => {
             if (typeof data.instance !== 'object')
                 return;
@@ -199,16 +207,17 @@ class Loader extends core_1.Container {
                 return;
             this.loadCount += 1;
             const { name, version, author, peerDependencies } = pkg[0].pkg;
-            this.ctx.logger.info(`loaded module ${name} version: ${version} ${Array.isArray(author) ? `authors: ${author.join(',')}` : `author: ${author}`}`);
+            this.ctx.logger.info(this.ctx.format('loader.modules.load', [name, version, Array.isArray(author) ? author.join(',') : author]));
             const requiredVersion = peerDependencies['kotori-bot'];
-            if (!requiredVersion.includes('workspace') &&
-                (!consts_1.SUPPORTS_VERSION.exec(requiredVersion) || requiredVersion !== this.ctx.pkg.version)) {
-                if (consts_1.SUPPORTS_HALF_VERSION.exec(requiredVersion)) {
-                    this.ctx.logger.warn(`incomplete supported module version: ${requiredVersion}`);
-                }
-                else {
-                    this.ctx.logger.error(`unsupported module version: ${requiredVersion}`);
-                }
+            if (requiredVersion.includes('workspace') ||
+                constants_1.SUPPORTS_VERSION.exec(requiredVersion) ||
+                requiredVersion.includes(this.ctx.pkg.version))
+                return;
+            if (constants_1.SUPPORTS_HALF_VERSION.exec(requiredVersion)) {
+                this.ctx.logger.warn(this.ctx.format('loader.modules.incomplete', [requiredVersion]));
+            }
+            else {
+                this.ctx.logger.error(this.ctx.format('loader.modules.unsupported', [requiredVersion]));
             }
         });
     }
@@ -219,7 +228,7 @@ class Loader extends core_1.Container {
     loadAllModules() {
         this.ctx.get('runner').loadAll();
         const failLoadCount = this.ctx.get('runner')[core_1.Symbols.modules].size - this.loadCount;
-        this.ctx.logger.info(`loaded ${this.loadCount} modules successfully${failLoadCount > 0 ? `, failed to load ${failLoadCount} modules` : ''} `);
+        this.ctx.logger.info(this.ctx.format(`loader.modules.all${failLoadCount > 0 ? '.fail' : ''}`, [this.loadCount, failLoadCount]));
         this.loadAllAdapter();
         this.ctx.emit('ready');
     }
@@ -228,13 +237,11 @@ class Loader extends core_1.Container {
         Object.keys(this.ctx.config.adapter).forEach((botName) => {
             const botConfig = this.ctx.config.adapter[botName];
             const array = adapters.get(botConfig.extends);
-            if (!array) {
-                this.ctx.logger.warn(`cannot find adapter '${botConfig.extends}' for ${botName}`);
-                return;
-            }
+            if (!array)
+                return this.ctx.logger.warn(this.ctx.format('loader.adapters.notfound', [botConfig.extends, botName]));
             const result = array[1]?.parseSafe(botConfig);
             if (result && !result.value)
-                throw new core_1.ModuleError(`Config format of adapter ${botName} is error: ${result.error.message}`);
+                throw new core_1.ModuleError(this.ctx.format('error.module.config_bot', [botName, result.error.message]));
             const bot = new array[0](this.ctx.extends({}, `${botConfig.extends}/${botName}`), result ? result.data : botConfig, botName);
             this.ctx.on('ready', () => bot.start());
             this.ctx.on('dispose', () => bot.stop());
@@ -243,16 +250,16 @@ class Loader extends core_1.Container {
     async checkUpdate() {
         const { version } = this.ctx.pkg;
         const res = await this.ctx.http
-            .get("https://hotaru.icu/api/agent/?url=https://raw.githubusercontent.com/kotorijs/kotori/master/packages/kotori/package.json" /* GLOBAL.UPDATE */)
-            .catch(() => this.ctx.logger.error('get update failed, please check your network'));
+            .get("https://hotaru.icu/api/agent/?url=https://raw.githubusercontent.com/kotorijs/kotori/master/packages/core/package.json" /* GLOBAL.UPDATE */)
+            .catch(() => this.ctx.logger.error(this.ctx.locale('loader.tips.update.failed')));
         if (!res || !core_1.Tsu.Object({ version: core_1.Tsu.String() }).check(res)) {
-            this.ctx.logger.warn(`detection update failed`);
+            this.ctx.logger.warn(this.ctx.locale('loader.tips.update.failed'));
         }
         else if (version === res.version) {
-            this.ctx.logger.info('kotori is currently the latest version');
+            this.ctx.logger.info(this.ctx.locale('loader.tips.update.latest'));
         }
         else {
-            this.ctx.logger.warn(`the current version of Kotori is ${version}, and the latest version is ${res.version}. please go to ${"https://github.com/kotorijs/kotori" /* GLOBAL.REPO */} to update`);
+            this.ctx.logger.warn(this.ctx.format('loader.tips.update.available', [version, res.version, "https://github.com/kotorijs/kotori" /* GLOBAL.REPO */]));
         }
     }
 }

package/lib/{runner.d.ts → class/runner.d.ts}

@@ -1,4 +1,6 @@
 import { Context, LocaleType, ModuleConfig, Symbols } from '@kotori-bot/core';
+import { BUILD_MODE, DEV_MODE, DEV_SOURCE_MODE } from '../constants';
+import './loader';
 interface BaseDir {
     root: string;
     modules: string;
@@ -6,11 +8,12 @@ interface BaseDir {
     logs: string;
 }
 interface Options {
-    mode: 'dev' | 'build';
+    mode: typeof BUILD_MODE | typeof DEV_MODE | typeof DEV_SOURCE_MODE;
 }
 interface RunnerConfig {
     baseDir: BaseDir;
     options: Options;
+    level: number;
 }
 interface ModulePackage {
     name: string;
@@ -40,13 +43,16 @@ export declare const localeTypeSchema: import("@kotori-bot/core").UnionParser<[i
 export declare class Runner {
     readonly baseDir: BaseDir;
     readonly options: Options;
-    private ctx;
-    private isDev;
+    private readonly ctx;
+    private readonly isDev;
+    private readonly isSourceDev;
     readonly [Symbols.modules]: Map<string, [ModuleMeta, ModuleConfig]>;
     constructor(ctx: Context, config: RunnerConfig);
     private getDirFiles;
     private getModuleRootDir;
+    private checkModuleFiles;
     private getModuleList;
+    private loadLang;
     private loadEx;
     private unloadEx;
     loadAll(): void;

package/lib/{runner.js → class/runner.js}

@@ -27,12 +27,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Runner = exports.localeTypeSchema = void 0;
-const fs_1 = __importStar(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = __importStar(require("node:path"));
 const core_1 = require("@kotori-bot/core");
 const logger_1 = require("@kotori-bot/logger");
-const consts_1 = require("./consts");
-const logger_2 = __importDefault(require("./utils/logger"));
+const constants_1 = require("../constants");
+const logger_2 = __importDefault(require("../utils/logger"));
+require("./loader");
 exports.localeTypeSchema = core_1.Tsu.Union([
     core_1.Tsu.Union([core_1.Tsu.Literal('en_US'), core_1.Tsu.Literal('ja_JP')]),
     core_1.Tsu.Union([core_1.Tsu.Literal('zh_TW'), core_1.Tsu.Any()])
@@ -75,18 +76,37 @@ class Runner {
     options;
     ctx;
     isDev;
+    isSourceDev;
     [core_1.Symbols.modules] = new Map();
     constructor(ctx, config) {
         this.ctx = ctx;
         /* handle config */
         this.baseDir = config.baseDir;
         this.options = config.options;
-        this.isDev = this.options.mode === 'dev';
+        this.isDev = this.options.mode.startsWith(constants_1.DEV_MODE);
+        this.isSourceDev = this.options.mode === constants_1.DEV_SOURCE_MODE;
         const loggerOptions = {
-            level: this.isDev ? logger_1.LoggerLevel.TRACE : logger_1.LoggerLevel.INFO,
+            level: this.ctx.config.global.level ?? config.level,
             label: [],
             transports: [
-                new logger_1.ConsoleTransport(),
+                new logger_1.ConsoleTransport({
+                    template: '%time% %type% %label%%msg%',
+                    label: '[%name%] ',
+                    labelColor: 'cyan',
+                    time: 'M/D H:m:s',
+                    timeColor: 'blue',
+                    pidColor: 'bold',
+                    useColor: true,
+                    detail: {
+                        FATAL: ['FATAL', 'redBright', 'redBright'],
+                        ERROR: ['ERROR', 'red', 'red'],
+                        WARN: ['WARN', 'yellowBright', 'yellowBright'],
+                        INFO: ['INFO', 'green'],
+                        DEBUG: ['DEBUG', 'magenta', 'magentaBright'],
+                        TRACE: ['TRACE', 'gray', 'gray']
+                    },
+                    indent: 2
+                }),
                 new logger_1.FileTransport({ dir: this.baseDir.logs, filter: (data) => data.level >= logger_1.LoggerLevel.WARN })
             ]
         };
@@ -94,90 +114,116 @@ class Runner {
         ctx.inject('logger');
     }
     getDirFiles(rootDir) {
-        const files = fs_1.default.readdirSync(rootDir);
+        const files = node_fs_1.default.readdirSync(rootDir);
         const list = [];
         files.forEach((fileName) => {
-            const file = path_1.default.join(rootDir, fileName);
-            if (fs_1.default.statSync(file).isDirectory()) {
+            const file = node_path_1.default.join(rootDir, fileName);
+            if (node_fs_1.default.statSync(file).isDirectory()) {
                 list.push(...this.getDirFiles(file));
             }
-            if (path_1.default.parse(file).ext !== (this.isDev ? consts_1.DEV_FILE : consts_1.BUILD_FILE))
+            if (node_path_1.default.parse(file).ext !== (this.isSourceDev ? constants_1.DEV_FILE : constants_1.BUILD_FILE))
                 return;
-            list.push(path_1.default.resolve(file));
+            list.push(node_path_1.default.resolve(file));
         });
         return list;
     }
     getModuleRootDir() {
         const moduleRootDir = [];
         [
-            ...this.ctx.config.global.dirs.map((dir) => path_1.default.resolve(this.ctx.baseDir.root, dir)),
+            ...this.ctx.config.global.dirs.map((dir) => node_path_1.default.resolve(this.ctx.baseDir.root, dir)),
             this.ctx.baseDir.modules
         ].forEach((dir) => {
-            if (fs_1.default.existsSync(dir) && fs_1.default.statSync(dir).isDirectory())
+            if (node_fs_1.default.existsSync(dir) && node_fs_1.default.statSync(dir).isDirectory())
                 moduleRootDir.push(dir);
         });
         return moduleRootDir;
     }
-    getModuleList(rootDir) {
-        fs_1.default.readdirSync(rootDir).forEach(async (fileName) => {
-            const dir = path_1.default.join(rootDir, fileName);
-            if (!fs_1.default.statSync(dir).isDirectory())
-                return;
-            if (rootDir !== this.ctx.baseDir.modules && !fileName.startsWith(core_1.PLUGIN_PREFIX))
-                return;
-            const packagePath = path_1.default.join(dir, 'package.json');
-            let pkg;
-            if (!fs_1.default.existsSync(packagePath))
+    async checkModuleFiles(rootDir, filename) {
+        const dir = node_path_1.default.join(rootDir, filename);
+        if (!node_fs_1.default.statSync(dir).isDirectory())
+            return;
+        if (rootDir !== this.ctx.baseDir.modules && !filename.startsWith(core_1.PLUGIN_PREFIX))
+            return;
+        const packagePath = node_path_1.default.join(dir, 'package.json');
+        let pkg;
+        if (!node_fs_1.default.existsSync(packagePath))
+            return;
+        try {
+            pkg = JSON.parse(node_fs_1.default.readFileSync(packagePath).toString());
+        }
+        catch {
+            throw new core_1.DevError(this.ctx.format('error.dev.package.illegal', [packagePath]));
+        }
+        const result = modulePackageSchema.parseSafe(pkg);
+        if (!result.value) {
+            if (rootDir !== this.ctx.baseDir.modules)
                 return;
-            try {
-                pkg = JSON.parse(fs_1.default.readFileSync(packagePath).toString());
-            }
-            catch {
-                throw new core_1.DevError(`illegal package.json ${packagePath}`);
-            }
-            const result = modulePackageSchema.parseSafe(pkg);
-            if (!result.value) {
-                if (rootDir !== this.ctx.baseDir.modules)
-                    return;
-                throw new core_1.DevError(`package.json format error ${packagePath}: ${result.error.message}`);
-            }
-            pkg = result.data;
-            const devMode = this.isDev && (0, fs_1.existsSync)(path_1.default.resolve(dir, consts_1.DEV_IMPORT));
-            const main = path_1.default.resolve(dir, devMode ? consts_1.DEV_IMPORT : pkg.main);
-            if (!fs_1.default.existsSync(main))
-                throw new core_1.DevError(`cannot find ${main}`);
-            const dirs = path_1.default.join(dir, devMode ? consts_1.DEV_CODE_DIRS : path_1.default.dirname(pkg.main));
-            const files = fs_1.default.statSync(dirs).isDirectory() ? this.getDirFiles(dirs) : [];
-            this[core_1.Symbols.modules].set(pkg.name, [
-                { pkg, files, main },
-                this.ctx.config.plugin[(0, core_1.stringRightSplit)(pkg.name, core_1.PLUGIN_PREFIX)] || {}
-            ]);
+            throw new core_1.DevError(this.ctx.format('error.dev.package.missing', [packagePath, result.error.message]));
+        }
+        pkg = result.data;
+        const devMode = this.isSourceDev && (0, node_fs_1.existsSync)(node_path_1.default.resolve(dir, constants_1.DEV_IMPORT));
+        const main = node_path_1.default.resolve(dir, devMode ? constants_1.DEV_IMPORT : pkg.main);
+        if (!node_fs_1.default.existsSync(main))
+            throw new core_1.DevError(this.ctx.format('error.dev.main_file', [main]));
+        const dirs = node_path_1.default.join(dir, devMode ? constants_1.DEV_CODE_DIRS : node_path_1.default.dirname(pkg.main));
+        const files = node_fs_1.default.statSync(dirs).isDirectory() ? this.getDirFiles(dirs) : [];
+        this[core_1.Symbols.modules].set(pkg.name, [
+            { pkg, files, main },
+            this.ctx.config.plugin[(0, core_1.stringRightSplit)(pkg.name, core_1.PLUGIN_PREFIX)] || {}
+        ]);
+    }
+    getModuleList(rootDir) {
+        this.ctx.logger.trace('load dirs:', rootDir);
+        node_fs_1.default.readdirSync(rootDir).forEach(async (filename) => {
+            await this.checkModuleFiles(rootDir, filename);
         });
     }
-    loadEx(instance, config) {
+    loadLang(lang) {
+        if (lang)
+            this.ctx.i18n.use((0, node_path_1.resolve)(...(Array.isArray(lang) ? lang : [lang])));
+    }
+    loadEx(instance, origin) {
+        this.ctx.logger.trace('module:', instance, origin);
+        const parsed = (schema) => {
+            const result = schema.parseSafe(config);
+            if (!result.value)
+                throw new core_1.ModuleError(this.ctx.format('error.module.config', [pkg.name, result.error.message]));
+            return result.data;
+        };
         const { main, pkg } = instance;
         /* eslint-disable-next-line import/no-dynamic-require, global-require, @typescript-eslint/no-var-requires */
         let obj = require(main);
-        let handle = config;
+        let config = origin;
         const adapterName = pkg.name.split(core_1.ADAPTER_PREFIX)[1];
         if (core_1.Adapter.isPrototypeOf.call(core_1.Adapter, obj.default) &&
             adapterName &&
             (!obj.config || obj.config instanceof core_1.Parser)) {
+            /* Adapter Class */
             this.ctx[core_1.Symbols.adapter].set(adapterName, [obj.default, obj.config]);
             obj = {};
         }
         else if (core_1.Service.isPrototypeOf.call(core_1.Service, obj.default)) {
+            /* Service Class */
             obj = {};
         }
         else if (obj.config instanceof core_1.Parser) {
-            const result = obj.config.parseSafe(handle);
-            if (!result.value)
-                throw new core_1.ModuleError(`Config format of module ${pkg.name} is error: ${result.error.message}`);
-            handle = result.data;
+            config = parsed(obj.config);
         }
         if (obj.lang)
-            this.ctx.i18n.use(Array.isArray(obj.lang) ? path_1.default.resolve(...obj.lang) : path_1.default.resolve(obj.lang));
-        this.ctx.load({ name: pkg.name, ...obj, config: handle });
+            this.loadLang(obj.lang);
+        if (obj.default) {
+            if (obj.default.lang)
+                this.loadLang(obj.default.lang);
+            if (obj.default.config instanceof core_1.Parser)
+                config = parsed(obj.default.config);
+        }
+        else if (obj.Main) {
+            if (obj.Main.lang)
+                this.loadLang(obj.Main.lang);
+            if (obj.Main.config instanceof core_1.Parser)
+                config = parsed(obj.Main.config);
+        }
+        this.ctx.load({ name: pkg.name, ...obj, config });
     }
     unloadEx(instance) {
         instance.files.forEach((file) => delete require.cache[require.resolve(file)]);
@@ -194,8 +240,8 @@ class Runner {
             this.watcher();
     }
     watcher() {
-        this[core_1.Symbols.modules].forEach((data) => data[0].files.forEach((file) => fs_1.default.watchFile(file, async () => {
-            this.ctx.logger.debug(`file happen changed, module ${data[0].pkg.name} is reloading...`);
+        this[core_1.Symbols.modules].forEach((data) => data[0].files.forEach((file) => node_fs_1.default.watchFile(file, async () => {
+            this.ctx.logger.debug(this.ctx.format('loader.debug.reload', [data[0].pkg.name]));
             this.unloadEx(data[0]);
             this.loadEx(...data);
         })));

package/lib/{consts.d.ts → constants.d.ts}

@@ -6,3 +6,6 @@ export declare const BUILD_CONFIG_NAME = "kotori.yml";
 export declare const DEV_CONFIG_NAME = "kotori.dev.yml";
 export declare const SUPPORTS_VERSION: RegExp;
 export declare const SUPPORTS_HALF_VERSION: RegExp;
+export declare const BUILD_MODE: "build";
+export declare const DEV_MODE: "dev";
+export declare const DEV_SOURCE_MODE: "dev-source";

package/lib/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_SOURCE_MODE = exports.DEV_MODE = exports.BUILD_MODE = exports.SUPPORTS_HALF_VERSION = exports.SUPPORTS_VERSION = exports.DEV_CONFIG_NAME = exports.BUILD_CONFIG_NAME = exports.DEV_IMPORT = exports.DEV_CODE_DIRS = exports.BUILD_FILE = exports.DEV_FILE = void 0;
+exports.DEV_FILE = '.ts';
+exports.BUILD_FILE = '.js';
+exports.DEV_CODE_DIRS = './src/';
+exports.DEV_IMPORT = `${exports.DEV_CODE_DIRS}index.ts`;
+exports.BUILD_CONFIG_NAME = 'kotori.yml';
+exports.DEV_CONFIG_NAME = 'kotori.dev.yml';
+exports.SUPPORTS_VERSION = /(1\.1\.0)|(1\.2\.0)|(1\.3\.(.*))|(1\.4\.(.*))/;
+exports.SUPPORTS_HALF_VERSION = /(x\.x\.(.*?))/;
+exports.BUILD_MODE = 'build';
+exports.DEV_MODE = 'dev';
+exports.DEV_SOURCE_MODE = 'dev-source';

package/lib/decorators/index.d.ts

@@ -0,0 +1,5 @@
+import Decorators from './utils';
+export declare function plugins(plugin: string | string[] | {
+    name: string;
+}): Decorators;
+export default plugins;

package/lib/decorators/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugins = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const core_1 = require("@kotori-bot/core");
+const utils_1 = __importDefault(require("./utils"));
+function plugins(plugin) {
+    let pkgName;
+    if (!Array.isArray(plugin) && typeof plugin === 'object') {
+        pkgName = plugin.name;
+    }
+    else {
+        pkgName = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.resolve)(...(Array.isArray(plugin) ? plugin : [plugin]), 'package.json')).toString()).name;
+    }
+    const pluginName = pkgName.split(core_1.PLUGIN_PREFIX)[1] ?? pkgName;
+    const ctx = core_1.Container.getInstance().extends(undefined, pluginName);
+    return new utils_1.default(ctx);
+}
+exports.plugins = plugins;
+exports.default = plugins;

package/lib/decorators/utils.d.ts

@@ -0,0 +1,35 @@
+import { Context, EventsList, CommandAccess, MessageScope } from '@kotori-bot/core';
+export declare class Decorators {
+    private readonly ctx;
+    private isCreated;
+    private pkgName;
+    private object?;
+    private register;
+    constructor(ctx: Context);
+    readonly import: (Target: object) => void;
+    readonly lang: <T extends object>(target: T, property: keyof T) => void;
+    readonly inject: <T extends object>(target: T, property: keyof T) => void;
+    readonly schema: <T extends object>(Target: T, property: keyof T) => void;
+    on<T extends keyof EventsList>(meta: {
+        type: T;
+    }): (...args: any[]) => void;
+    once<T extends keyof EventsList>(meta: {
+        type: T;
+    }): (...args: any[]) => void;
+    midware(meta?: {
+        priority: number;
+    }): (...args: any[]) => void;
+    command(meta: {
+        template: string;
+        alias?: string[];
+        description?: string;
+        help?: string;
+        scope?: MessageScope | 'all';
+        access?: CommandAccess;
+        options?: [string, string][];
+    }): (...args: any[]) => void;
+    regexp(meta: {
+        match: RegExp;
+    }): (...args: any[]) => void;
+}
+export default Decorators;

package/lib/decorators/utils.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decorators = void 0;
+const node_path_1 = require("node:path");
+const core_1 = require("@kotori-bot/core");
+class Decorators {
+    ctx;
+    isCreated = false;
+    pkgName;
+    object;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    register(callback) {
+        return (...args) => this.ctx.parent.once('ready_module', (data) => {
+            if (data.instance.name === this.pkgName) {
+                callback(...args);
+                return;
+            }
+            this.register(callback);
+        });
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.pkgName = `${core_1.PLUGIN_PREFIX}${ctx.identity}`;
+    }
+    import = (Target) => {
+        this.register(() => {
+            if (!this.isCreated)
+                this.schema(Target, undefined);
+        })();
+    };
+    lang = (target, property) => {
+        this.register(() => {
+            const lang = target[property];
+            this.ctx.parent.i18n.use((0, node_path_1.resolve)(...(Array.isArray(lang) ? lang : [lang])));
+        })();
+    };
+    inject = (target, property) => {
+        this.register(() => {
+            const inject = target[property];
+            inject.forEach((identity) => this.ctx[core_1.Tokens.container].forEach((service, name) => {
+                if (!(service instanceof core_1.Service) || service.identity !== identity)
+                    return;
+                this.ctx.inject(name);
+            }));
+        })();
+    };
+    schema = (Target, property) => {
+        this.register(() => {
+            let config = (this.ctx[core_1.Symbols.modules].get(this.pkgName) ?? [])[1];
+            const result = Target[property].parseSafe(config);
+            if (!result.value)
+                throw new core_1.ModuleError(`Config format of module ${this.pkgName} is error: ${result.error.message}`);
+            config = result.data;
+            if (this.isCreated)
+                return;
+            this.isCreated = true;
+            this.object = new Target(this.ctx, config);
+        })();
+    };
+    on(meta) {
+        return this.register((target, property) => this.ctx.on(meta.type, (...args) => target[property].bind(this.object)(...args)));
+    }
+    once(meta) {
+        return this.register((target, property) => this.ctx.once(meta.type, (...args) => target[property].bind(this.object)(...args)));
+    }
+    midware(meta) {
+        return this.register((target, property) => this.ctx.midware((next, session) => target[property].bind(this.object)(next, session), meta?.priority));
+    }
+    command(meta) {
+        return this.register((target, property) => {
+            const command = this.ctx
+                .command(meta.template, meta)
+                .action((data, session) => target[property].bind(this.object)(data, session));
+            meta.options?.forEach(([name, template]) => command.option(name, template));
+        });
+    }
+    regexp(meta) {
+        return this.register((target, property) => this.ctx.regexp(meta.match, (match, session) => target[property].bind(this.object)(match, session)));
+    }
+}
+exports.Decorators = Decorators;
+exports.default = Decorators;

package/lib/index.d.ts

@@ -1,3 +1,5 @@
-export * from './loader';
-export * from './consts';
+export * from './class/loader';
+export * from './constants';
+export * from './decorators';
+export * from './types';
 export * from '@kotori-bot/logger';

package/lib/index.js

@@ -4,7 +4,7 @@
  * @Blog: https://hotaru.icu
  * @Date: 2023-10-29 16:20:51
  * @LastEditors: Hotaru biyuehuya@gmail.com
- * @LastEditTime: 2024-02-20 20:20:54
+ * @LastEditTime: 2024-05-26 15:36:01
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -21,6 +21,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./loader"), exports);
-__exportStar(require("./consts"), exports);
+__exportStar(require("./class/loader"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./types"), exports);
 __exportStar(require("@kotori-bot/logger"), exports);

package/lib/service/adapter.d.ts

@@ -0,0 +1,15 @@
+import { Api, Adapter as OriginAdapter } from '@kotori-bot/core';
+import { WsRouteHandler } from '../types/server';
+export declare namespace Adapter {
+    abstract class WebSocket<T extends Api = Api> extends OriginAdapter<T> {
+        private isSetup;
+        private destroyFn?;
+        protected destroy(): void;
+        protected setup(): void;
+        abstract handle<T extends object>(data: T): void;
+        connection?: (ws: Parameters<WsRouteHandler>[0], req: Parameters<WsRouteHandler>[1]) => void;
+        start(): void;
+        stop(): void;
+    }
+}
+export default Adapter;

package/lib/service/adapter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Adapter = void 0;
+const core_1 = require("@kotori-bot/core");
+/* eslint-disable-next-line @typescript-eslint/no-namespace */
+var Adapter;
+(function (Adapter) {
+    class WebSocket extends core_1.Adapter {
+        isSetup = false;
+        destroyFn;
+        destroy() {
+            if (!this.destroyFn)
+                return;
+            this.destroyFn();
+            this.isSetup = false;
+        }
+        setup() {
+            if (this.isSetup)
+                return;
+            this.ctx.inject('server');
+            this.destroyFn = this.ctx.server.wss(`/adapter/${this.identity}`, (ws, req) => {
+                if (this.connection)
+                    this.connection(ws, req);
+                ws.on('message', (raw) => {
+                    let data;
+                    try {
+                        data = JSON.parse(raw.toString());
+                    }
+                    catch (e) {
+                        this.ctx.logger.error(`Data parse error: ${e instanceof Error ? e.message : e}`);
+                    }
+                    if (data)
+                        this.handle(data);
+                });
+            });
+            this.isSetup = true;
+        }
+        connection;
+        start() {
+            this.setup();
+        }
+        stop() {
+            this.destroy();
+        }
+    }
+    Adapter.WebSocket = WebSocket;
+})(Adapter || (exports.Adapter = Adapter = {}));
+exports.default = Adapter;

package/lib/service/file.d.ts

@@ -3,7 +3,7 @@ export declare class File extends Service {
     constructor(ctx: Context);
     getDir(): string;
     getFile(filename: string): string;
-    load(filename: string, type?: Parameters<typeof loadConfig>[1], init?: Parameters<typeof loadConfig>[2]): string | object | unknown[] | null;
+    load<T = Parameters<typeof saveConfig>[1]>(filename: string, type?: Parameters<typeof loadConfig>[1], init?: Parameters<typeof loadConfig>[2]): T;
     save(filename: string, data: Parameters<typeof saveConfig>[1], type?: Parameters<typeof saveConfig>[2]): void;
     create(filename: string, data?: Parameters<typeof createConfig>[1], type?: Parameters<typeof createConfig>[2]): void;
 }

package/lib/service/file.js

@@ -2,17 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.File = void 0;
 const core_1 = require("@kotori-bot/core");
-const path_1 = require("path");
+const node_path_1 = require("node:path");
 class File extends core_1.Service {
     constructor(ctx) {
         super(ctx, {}, 'file');
     }
     getDir() {
-        return (0, path_1.join)(this.ctx.baseDir.data, ...(this.ctx.identity ? this.ctx.identity.split('/') : []));
+        return (0, node_path_1.join)(this.ctx.baseDir.data, ...(this.ctx.identity ? this.ctx.identity.split('/') : []));
     }
     getFile(filename) {
-        return (0, path_1.join)(this.getDir(), filename);
+        return (0, node_path_1.join)(this.getDir(), filename);
     }
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
     load(filename, type, init) {
         return (0, core_1.loadConfig)(this.getFile(filename), type, init);
     }

package/lib/service/server.d.ts

@@ -1,26 +1,63 @@
-/// <reference types="body-parser" />
-/// <reference types="connect" />
-/// <reference types="serve-static" />
+/// <reference types="node" />
+/// <reference types="node" />
 import { Context, Service } from '@kotori-bot/core';
-import express from 'express';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { HttpRouteHandler, HttpRoutes, WsRouteHandler } from '../types/server';
 interface ServerConfig {
     port: number;
 }
-export declare class Server extends Service<ServerConfig> {
+interface BodyParserOptions {
+    inflate?: boolean | undefined;
+    limit?: number | string | undefined;
+    type?: string | string[] | ((req: IncomingMessage) => any) | undefined;
+    verify?(req: IncomingMessage, res: ServerResponse, buf: Buffer, encoding: string): void;
+}
+interface UrlencodedOptions extends BodyParserOptions {
+    extended?: boolean | undefined;
+    parameterLimit?: number | undefined;
+}
+interface ServeStaticOptions<R extends ServerResponse = ServerResponse> {
+    acceptRanges?: boolean | undefined;
+    cacheControl?: boolean | undefined;
+    dotfiles?: string | undefined;
+    etag?: boolean | undefined;
+    extensions?: string[] | false | undefined;
+    fallthrough?: boolean | undefined;
+    immutable?: boolean | undefined;
+    index?: boolean | string | string[] | undefined;
+    lastModified?: boolean | undefined;
+    maxAge?: number | string | undefined;
+    redirect?: boolean | undefined;
+    setHeaders?: ((res: R, path: string, stat: any) => any) | undefined;
+}
+interface RouterOptions {
+    caseSensitive?: boolean | undefined;
+    /**
+     * @default false
+     * @since 4.5.0
+     */
+    mergeParams?: boolean | undefined;
+    strict?: boolean | undefined;
+}
+export declare class Server extends Service<ServerConfig> implements HttpRoutes {
     private app;
-    private server?;
+    private server;
+    private wsServer;
+    private wsRoutes;
     constructor(ctx: Context, config: ServerConfig);
     start(): void;
     stop(): void;
-    get: Server['app']['get'];
-    post: Server['app']['post'];
-    patch: Server['app']['patch'];
-    put: Server['app']['put'];
-    delete: Server['app']['delete'];
-    all: Server['app']['all'];
-    use: Server['app']['use'];
-    router: typeof express.Router;
-    json: (options?: import("body-parser").OptionsJson | undefined) => import("connect").NextHandleFunction;
-    static: import("serve-static").RequestHandlerConstructor<express.Response<any, Record<string, any>>>;
+    get<P extends string>(path: P, ...callback: HttpRouteHandler<P>[]): void;
+    post<P extends string>(path: P, ...callback: HttpRouteHandler<P>[]): void;
+    patch<P extends string>(path: P, ...callback: HttpRouteHandler<P>[]): void;
+    put<P extends string>(path: P, ...callback: HttpRouteHandler<P>[]): void;
+    delete<P extends string>(path: P, ...callback: HttpRouteHandler<P>[]): void;
+    all<P extends string>(path: P, ...callback: HttpRouteHandler<P>[]): void;
+    use<P extends string>(path: P | HttpRouteHandler | HttpRoutes, ...callback: (HttpRouteHandler<P> | HttpRoutes)[]): void;
+    router: (options?: RouterOptions) => HttpRoutes;
+    json: (options?: BodyParserOptions) => HttpRouteHandler;
+    static: (root: string, options?: ServeStaticOptions) => HttpRouteHandler;
+    urlencoded: (options?: UrlencodedOptions) => HttpRouteHandler;
+    wss<P extends string>(path: P, callback: WsRouteHandler<P>): () => boolean;
 }
 export default Server;

package/lib/service/server.js

@@ -5,14 +5,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Server = void 0;
 const core_1 = require("@kotori-bot/core");
+const node_http_1 = require("node:http");
+const path_to_regexp_1 = require("path-to-regexp");
 const express_1 = __importDefault(require("express"));
+const ws_1 = __importDefault(require("ws"));
 class Server extends core_1.Service {
     app;
     server;
+    wsServer;
+    wsRoutes = new Map();
     constructor(ctx, config) {
         super(ctx, config, 'server');
         this.app = (0, express_1.default)();
-        this.app.use('/', (_, res, next) => {
+        this.app.use(express_1.default.json());
+        this.app.use('/', (req, res, next) => {
             let isWebui = false;
             ctx[core_1.Symbols.modules].forEach((module) => {
                 if (isWebui)
@@ -20,41 +26,84 @@ class Server extends core_1.Service {
                 if (module[0].pkg.name === '@kotori-bot/kotori-plugin-webui')
                     isWebui = true;
             });
-            if (!isWebui) {
-                res.setHeader('Content-type', 'text/html');
-                res.send(/* html */ `<h1>Welcome to kotori!</h1>`);
+            if (isWebui || req.url !== '/') {
+                next();
+                return;
             }
-            next();
+            res.setHeader('Content-type', 'text/html');
+            res.send(/* html */ `<h1>Welcome to kotori!</h1>`);
+        });
+        this.server = (0, node_http_1.createServer)(this.app);
+        this.wsServer = new ws_1.default.Server({ noServer: true });
+        this.server.on('upgrade', (req, socket, head) => {
+            this.wsServer.handleUpgrade(req, socket, head, (ws) => {
+                this.wsServer.emit('connection', ws, req);
+            });
+        });
+        this.wsServer.on('connection', (ws, req) => {
+            let triggered = false;
+            /* eslint-disable no-restricted-syntax,no-continue */
+            for (const [template, list] of this.wsRoutes.entries()) {
+                if (!req.url)
+                    continue;
+                const result = (0, path_to_regexp_1.match)(template, { decode: decodeURIComponent })(req.url);
+                if (!result)
+                    continue;
+                if (!triggered)
+                    triggered = true;
+                list.forEach((callback) => {
+                    callback(ws, Object.assign(req, { params: result.params }));
+                });
+            }
+            /* eslint-enable no-restricted-syntax,no-continue */
+            if (!triggered)
+                ws.close(1002);
         });
-        this.get = this.app.get.bind(this.app);
-        this.post = this.app.post.bind(this.app);
-        this.patch = this.app.patch.bind(this.app);
-        this.put = this.app.put.bind(this.app);
-        this.delete = this.app.delete.bind(this.app);
-        this.use = this.app.use.bind(this.app);
-        this.all = this.app.all.bind(this.app);
     }
     start() {
-        if (this.server)
-            return;
-        this.server = this.app.listen(this.config.port);
-        this.ctx.logger.label('server').info(`server start at http://127.0.0.1:${this.config.port}`);
+        this.server.listen(this.config.port, () => {
+            this.ctx.logger.label('server').info(`http server start at http://127.0.0.1:${this.config.port}`);
+            this.ctx.logger.label('server').info(`websocket server start at ws://127.0.0.1:${this.config.port}`);
+        });
     }
     stop() {
-        if (!this.server)
-            return;
+        this.wsServer.close();
         this.server.close();
     }
-    get;
-    post;
-    patch;
-    put;
-    delete;
-    all;
-    use;
+    get(path, ...callback) {
+        this.app.get(path, ...callback);
+    }
+    post(path, ...callback) {
+        this.app.post(path, ...callback);
+    }
+    patch(path, ...callback) {
+        this.app.patch(path, ...callback);
+    }
+    put(path, ...callback) {
+        this.app.put(path, ...callback);
+    }
+    delete(path, ...callback) {
+        this.app.delete(path, ...callback);
+    }
+    all(path, ...callback) {
+        this.app.all(path, ...callback);
+    }
+    use(path, ...callback) {
+        if (typeof path === 'string')
+            this.app.use(path, ...callback);
+        else
+            this.app.use('/', path, ...callback);
+    }
     router = express_1.default.Router;
     json = express_1.default.json;
     static = express_1.default.static;
+    urlencoded = express_1.default.urlencoded;
+    wss(path, callback) {
+        const list = this.wsRoutes.get(path) || new Set();
+        list.add(callback);
+        this.wsRoutes.set(path, list);
+        return () => list.delete(callback);
+    }
 }
 exports.Server = Server;
 exports.default = Server;

package/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from './server';

package/lib/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./server"), exports);

package/lib/types/server.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { NextFunction, Request, Response } from 'express';
+import { IncomingMessage } from 'node:http';
+import Ws from 'ws';
+type RemoveTail<S extends string, Tail extends string> = S extends `${infer P}${Tail}` ? P : S;
+type GetRouteParameter<S extends string> = RemoveTail<RemoveTail<RemoveTail<S, `/${string}`>, `-${string}`>, `.${string}`>;
+interface ParamsDictionary {
+    [key: string]: string;
+}
+type RouteParameters<Route extends string> = string extends Route ? ParamsDictionary : Route extends `${string}(${string}` ? ParamsDictionary : Route extends `${string}:${infer Rest}` ? (GetRouteParameter<Rest> extends never ? ParamsDictionary : GetRouteParameter<Rest> extends `${infer ParamName}?` ? {
+    [P in ParamName]?: string;
+} : {
+    [P in GetRouteParameter<Rest>]: string;
+}) & (Rest extends `${GetRouteParameter<Rest>}${infer Next}` ? RouteParameters<Next> : unknown) : object;
+export type HttpRouteHandler<P extends string = string> = (req: Request<RouteParameters<P>>, res: Response, next: NextFunction) => unknown;
+type KeyList = 'get' | 'post' | 'patch' | 'put' | 'delete' | 'all';
+export type WsRouteHandler<P extends string = ''> = (ws: Ws, req: IncomingMessage & {
+    params: RouteParameters<P>;
+}) => void;
+type HttpRoutesReflect = {
+    [K in KeyList]: <P extends string>(path: P, ...callback: HttpRouteHandler<P>[]) => unknown;
+};
+export interface HttpRoutes extends HttpRoutesReflect {
+    use<P extends string>(path: P, ...callback: (HttpRouteHandler<P> | HttpRoutes)[]): unknown;
+    use(...callback: (HttpRouteHandler | HttpRoutes)[]): unknown;
+}
+export {};

package/lib/types/server.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kotori-bot/loader",
-  "version": "1.4.2",
+  "version": "1.5.0-beta.1",
   "description": "Loader For KotoriBot",
   "license": "GPL-3.0",
   "main": "lib/index.js",
@@ -24,9 +24,11 @@
   },
   "homepage": "https://kotori.js.org",
   "dependencies": {
+    "@types/ws": "^8.5.8",
     "express": "^4.18.2",
     "knex": "^3.1.0",
-    "@kotori-bot/core": "^1.3.0",
+    "ws": "^8.14.2",
+    "@kotori-bot/core": "^1.4.0",
     "@kotori-bot/logger": "^1.2.0"
   },
   "devDependencies": {

package/lib/consts.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUPPORTS_HALF_VERSION = exports.SUPPORTS_VERSION = exports.DEV_CONFIG_NAME = exports.BUILD_CONFIG_NAME = exports.DEV_IMPORT = exports.DEV_CODE_DIRS = exports.BUILD_FILE = exports.DEV_FILE = void 0;
-exports.DEV_FILE = '.ts';
-exports.BUILD_FILE = '.js';
-exports.DEV_CODE_DIRS = './src/';
-exports.DEV_IMPORT = `${exports.DEV_CODE_DIRS}index.ts`;
-exports.BUILD_CONFIG_NAME = 'kotori.yml';
-exports.DEV_CONFIG_NAME = 'kotori.dev.yml';
-exports.SUPPORTS_VERSION = /(1\.1\.0)|(1\.2\.0)|(1\.3\.(.*?))/;
-exports.SUPPORTS_HALF_VERSION = /(x\.x\.(.*?))/;