@zhin.js/core 1.0.0 → 1.0.2

package/src/jsx.ts

@@ -0,0 +1,92 @@
+import { MaybePromise } from '@zhin.js/types';
+import { SendContent,MessageElement } from './types.js';
+import { MessageComponent } from './message.js';
+import { Component, ComponentContext } from './component.js';
+
+
+// JSX 子元素类型
+export type JSXChildren = MessageElement | string | number | boolean | null | undefined | JSXChildren[];
+
+// JSX 元素类型
+export type JSXElementType = string | Component<any> ;
+
+// JSX 属性类型
+export type JSXProps = Record<string, any> & {
+    children?: JSXChildren;
+};
+export {Fragment} from './component.js'
+// 全局 JSX 命名空间
+declare global {
+    namespace JSX {
+        interface Element extends MessageComponent<any> {}
+        interface ElementClass {
+            render(props: any, context?: ComponentContext): MaybePromise<SendContent>;
+        }
+        interface ElementAttributesProperty {
+            data: {};
+        }
+        interface ElementChildrenAttribute {
+            children: {};
+        }
+        interface IntrinsicElements {
+            [elemName: string]: any;
+        }
+    }
+}
+
+// JSX 运行时函数
+export function jsx(type: JSXElementType, data: JSXProps): MessageElement {
+    return {
+        type,
+        data,
+    } as MessageElement;
+}
+
+// JSX Fragment 支持
+export function jsxs(type: JSXElementType, props: JSXProps): MessageElement {
+    return jsx(type, props);
+}
+
+
+// JSX 渲染函数
+export async function renderJSX(element: MessageComponent<any>, context?: ComponentContext): Promise<SendContent> {
+    if (typeof element.type === 'string') {
+        if (element.type === 'Fragment') {
+            return await renderChildren(element.data.children, context);
+        }
+        // 其他内置组件处理
+        return await renderChildren(element.data.children, context);
+    } else if (typeof element.type === 'function') {
+        // 函数组件
+        const component = element.type as Component<any>;
+        return await component(element.data, context || {} as ComponentContext);
+    } else {
+        // 类组件或其他类型
+        const component = element.type as Component<any>;
+        return await component(element.data, context || {} as ComponentContext);
+    }
+}
+
+// 渲染子元素
+async function renderChildren(children: JSXChildren, context?: ComponentContext): Promise<SendContent> {
+    if (children == null) return '';
+    if (typeof children === 'string' || typeof children === 'number' || typeof children === 'boolean') {
+        return String(children);
+    }
+    if (Array.isArray(children)) {
+        const results = await Promise.all(children.map(async child => {
+            if (typeof child === 'string' || typeof child === 'number' || typeof child === 'boolean') {
+                return String(child);
+            }
+            if (child && typeof child === 'object' && 'type' in child) {
+                return await renderJSX(child as MessageComponent<any>, context);
+            }
+            return '';
+        }));
+        return results.join('');
+    }
+    if (children && typeof children === 'object' && 'type' in children) {
+        return await renderJSX(children as MessageComponent<any>, context);
+    }
+    return '';
+}

package/src/message.ts

@@ -0,0 +1,47 @@
+import {MessageElement, MessageSender, SendContent} from "./types";
+import { Component } from "./component.js";
+
+/**
+ * 消息组件类型：用于自定义消息结构
+ */
+export type MessageComponent<T extends object>={
+    type:Component<T&{children?:SendContent}>
+    data:T
+}
+/**
+ * 消息频道信息
+ */
+export interface MessageChannel{
+    id: string;
+    type: MessageType;
+}
+/**
+ * 消息类型枚举
+ */
+export type MessageType = 'group' | 'private' | 'channel'
+/**
+ * 消息基础结构
+ */
+export interface MessageBase {
+    $id: string;
+    $adapter:string
+    $bot:string
+    $content: MessageElement[];
+    $sender: MessageSender;
+    $reply(content:SendContent,quote?:boolean|string):Promise<void>
+    $channel: MessageChannel;
+    $timestamp: number;
+    $raw: string;
+}
+/**
+ * 完整消息类型，支持扩展
+ */
+export type Message<T extends object={}>=MessageBase&T;
+export namespace Message{
+    /**
+     * 工具方法：合并自定义字段与基础消息结构
+     */
+    export function from<T extends object>(input:T,format:MessageBase):Message<T>{
+        return Object.assign(input,format)
+    }
+}

package/src/plugin.ts

@@ -1,52 +1,123 @@
 // ============================================================================
-// 插件类型定义
+// 插件类型定义（定义插件中间件、生命周期、命令、组件等核心类型）
 // ============================================================================
 
 
 import {MaybePromise} from '@zhin.js/types'
-import { Message, BeforeSendHandler, SendOptions} from "./types";
+import {AdapterMessage, BeforeSendHandler, RegisteredAdapter, SendOptions} from "./types.js";
+import {Message} from './message.js'
 import {Dependency, Logger,} from "@zhin.js/hmr";
 import {App} from "./app";
+import {MessageCommand} from "./command.js";
+import {Component, renderComponents} from "./component.js";
+import { PluginError, MessageError, errorManager } from './errors.js';
+import {remove} from "./utils.js";
+import {Prompt} from "./prompt.js";
+import { Schema } from '@zhin.js/database';
+import { Cron} from './cron.js';
 
 /** 消息中间件函数 */
-export type MessageMiddleware = (message: Message, next: () => Promise<void>) => MaybePromise<void>;
-
-/** 事件监听器函数 */
-export type EventListener<T = any> = (data: T) => void | Promise<void>;
-
-/** 定时任务配置 */
-export interface CronJob {
-    name: string;
-    schedule: string; // cron 表达式
-    handler: () => void | Promise<void>;
-    enabled?: boolean;
-}
+export type MessageMiddleware<P extends RegisteredAdapter=RegisteredAdapter> = (message: Message<AdapterMessage<P>>, next: () => Promise<void>) => MaybePromise<void>;
 
 
 // ============================================================================
-// Plugin 类
+// Plugin 类（插件的生命周期、命令/中间件/组件/定时任务等管理）
 // ============================================================================
 
 /**
- * 插件类：继承自Dependency，提供机器人特定功能
+ * 插件类：继承自 Dependency，提供机器人特定功能与生命周期管理。
+ * 支持命令注册、中间件、组件、定时任务、模型等。
  */
 export class Plugin extends Dependency<Plugin> {
-    middlewares: MessageMiddleware[] = [];
-    eventListeners = new Map<string, EventListener[]>();
-    cronJobs = new Map<string, CronJob>();
-
+    middlewares: MessageMiddleware<any>[] = [];
+    components: Map<string, Component<any>> = new Map();
+    schemas: Map<string,Schema<any>>=new Map();
+    commands:MessageCommand[]=[];
+    crons:Cron[]=[];
     #logger?:Logger
+    /**
+     * 构造函数：初始化插件，注册消息事件、命令中间件、资源清理等
+     * @param parent 所属 App 实例
+     * @param name 插件名
+     * @param filePath 插件文件路径
+     */
     constructor(parent: Dependency<Plugin>, name: string, filePath: string) {
         super(parent, name, filePath);
+        // 绑定消息事件，自动分发到命令和中间件
         this.on('message.receive',this.#handleMessage.bind(this))
+        // 注册命令处理为默认中间件
+        this.addMiddleware(async (message,next)=>{
+            for(const command of this.commands){
+                const result=await command.handle(message);
+                if(result) message.$reply(result);
+            }
+            return next()
+        });
+        // 发送前渲染组件
+        this.beforeSend((options)=>renderComponents(this.components,options))
+        // 资源清理：卸载时清空模型、定时任务等
+        this.on('dispose',()=>{
+            for(const name of this.schemas.keys()){
+                this.app.database?.models.delete(name);
+            }
+            this.schemas.clear();
+            for(const cron of this.crons){
+                cron.dispose();
+            }
+            this.crons.length = 0;
+        });
+        // 挂载时启动定时任务
+        this.on('mounted',()=>{
+            for(const cron of this.crons){
+                cron.run();
+            }
+        });
     }
-    #handleMessage(message:Message){
-        const next=async (index:number)=>{
-            if(!this.middlewares[index]) return
-            const middleware=this.middlewares[index]
-            middleware(message,()=>next(index+1))
+    async #handleMessage(message: Message) {
+        try {
+            await this.#runMiddlewares(message, 0)
+        } catch (error) {
+            const messageError = new MessageError(
+                `消息处理失败: ${(error as Error).message}`,
+                message.$id,
+                message.$channel.id,
+                { pluginName: this.name, originalError: error }
+            )
+            
+            await errorManager.handle(messageError)
+            
+            // 可选：发送错误回复给用户
+            try {
+                await message.$reply('抱歉，处理您的消息时出现了错误。')
+            } catch (replyError) {
+                // 静默处理回复错误，避免错误循环
+                // console.error 已替换为注释
+            }
+        }
+    }
+    cron(cronExpression:string,callback:()=>void){
+        const cronJob = new Cron(cronExpression,callback);
+        this.crons.push(cronJob);
+        return this;
+    }
+    async #runMiddlewares(message: Message, index: number): Promise<void> {
+        if (index >= this.middlewares.length) return
+        
+        const middleware = this.middlewares[index]
+        
+        try {
+            await middleware(message, () => this.#runMiddlewares(message, index + 1))
+        } catch (error) {
+            throw new PluginError(
+                `中间件执行失败: ${(error as Error).message}`,
+                this.name,
+                { middlewareIndex: index, originalError: error }
+            )
         }
-        next(0)
+    }
+    defineModel<S extends Record<string,any>>(name:string,schema:Schema<S>){
+        this.schemas.set(name,schema);
+        return this;
     }
     beforeSend(handler:BeforeSendHandler){
         this.before('message.send',handler)
@@ -60,63 +131,74 @@ export class Plugin extends Dependency<Plugin> {
     }
     get logger(): Logger {
         if(this.#logger) return this.#logger
-        const names = [this.name];
+        const names = [];
         let temp=this as Dependency<Plugin>
         while(temp.parent){
-            names.unshift(temp.parent.name)
+            names.unshift(temp.name)
             temp=temp.parent
         }
-        return this.#logger=this.app.getLogger(...names)
+        return temp.getLogger(names.join('/'))
+    }
+    /** 添加组件 */
+    addComponent<T=any>(component:Component<T>){
+        this.components.set(component.name,component);
     }
-
     /** 添加中间件 */
-    addMiddleware(middleware: MessageMiddleware): void {
+    addCommand(command:MessageCommand){
+        this.commands.push(command);
+        this.dispatch('command.add',command);
+    }
+    /** 添加中间件 */
+    addMiddleware<T extends RegisteredAdapter>(middleware: MessageMiddleware<T>) {
         this.middlewares.push(middleware);
         this.dispatch('middleware.add',middleware)
-    }
-
-    /** 添加事件监听器 */
-    addEventListener<T = any>(event: string, listener: EventListener<T>): void {
-        if (!this.eventListeners.has(event)) {
-            this.eventListeners.set(event, []);
+        return ()=>{
+            remove(this.middlewares,middleware)
         }
-        this.eventListeners.get(event)!.push(listener);
-        this.dispatch('listener.add',event,listener)
     }
-
-    /** 添加定时任务 */
-    addCronJob(job: CronJob): void {
-        this.cronJobs.set(job.name, job);
-        this.dispatch('cron-job.add',job)
+    prompt<P extends RegisteredAdapter>(message:Message<AdapterMessage<P>>){
+        return new Prompt<P>(this,message)
     }
+
+
+
     /** 发送消息 */
-    async sendMessage(options:SendOptions): Promise<void> {
-        await this.app.sendMessage(options);
+    async sendMessage(options: SendOptions): Promise<void> {
+        try {
+            await this.app.sendMessage(options);
+        } catch (error) {
+            const messageError = new MessageError(
+                `发送消息失败: ${(error as Error).message}`,
+                undefined,
+                (options as any).channel_id,
+                { pluginName: this.name, sendOptions: options, originalError: error }
+            )
+            
+            await errorManager.handle(messageError)
+            throw messageError
+        }
     }
 
     /** 销毁插件 */
     dispose(): void {
-        // 移除所有中间件
-        for (const middleware of this.middlewares) {
-            this.dispatch('middleware.remove', middleware)
-        }
-        this.middlewares = []
-
-        // 移除所有事件监听器
-        for (const [event, listeners] of this.eventListeners) {
-            for (const listener of listeners) {
-                this.dispatch('listener.remove', event, listener)
+        try {
+            // 移除所有中间件
+            for (const middleware of this.middlewares) {
+                this.dispatch('middleware.remove', middleware)
             }
+            this.middlewares = []
+            
+            // 调用父类的dispose方法
+            super.dispose()
+        } catch (error) {
+            const pluginError = new PluginError(
+                `插件销毁失败: ${(error as Error).message}`,
+                this.name,
+                { originalError: error }
+            )
+            
+            errorManager.handle(pluginError).catch(console.error)
+            throw pluginError
         }
-        this.eventListeners.clear()
-
-        // 移除所有定时任务
-        for (const [name, job] of this.cronJobs) {
-            this.dispatch('cron-job.remove', job)
-        }
-        this.cronJobs.clear()
-
-        // 调用父类的dispose方法
-        super.dispose()
     }
 }

package/src/prompt.ts

@@ -0,0 +1,290 @@
+import {AdapterMessage, Dict, RegisteredAdapter} from './types.js';
+import { MessageMiddleware,Plugin } from './plugin.js';
+import { Message } from './message.js';
+import { Schema } from './schema.js';
+
+/**
+ * Prompt类：用于实现机器人与用户的交互式提问与输入收集。
+ * 支持文本、数字、确认、列表、选项、Schema等多种输入类型，自动处理超时、默认值、格式化等。
+ * 典型用法：await new Prompt(plugin, event).text('请输入内容')
+ * @template P 适配器类型
+ */
+export class Prompt<P extends RegisteredAdapter> {
+    /**
+     * 构造函数
+     * @param plugin 所属插件实例
+     * @param event 当前消息事件
+     */
+    constructor(private plugin:Plugin,private event: Message<AdapterMessage<P>>) {}
+    /**
+     * 获取当前会话唯一标识（适配器-机器人-频道-用户）
+     */
+    private getChannelAddress<P2 extends RegisteredAdapter>(event: Message<AdapterMessage<P2>>) {
+        return `${event.$adapter}-${event.$bot}-${event.$channel.type}:${event.$channel.id}-${event.$sender.id}`;
+    }
+    /**
+     * 通用提问方法，支持自定义格式化、超时、默认值等
+     * @param config 提问配置
+     */
+    private prompt<T = any>(config: Prompt.Config<T>) {
+        return new Promise<T>((resolve, reject) => {
+            this.event.$reply(config.tips);
+            this.middleware(
+                input => {
+                    if (input instanceof Error) {
+                        this.event.$reply(input.message);
+                        if (config.defaultValue) resolve(config.defaultValue);
+                        else reject(input);
+                        return;
+                    }
+                    resolve(config.format(input));
+                },
+                config.timeout,
+                config.timeoutText,
+            );
+        });
+    }
+    /**
+     * 注册一次性消息中间件，等待用户输入或超时
+     * @param callback 输入回调
+     * @param timeout 超时时间（默认3分钟）
+     * @param timeoutText 超时提示
+     */
+    middleware(callback: (input: string | Error) => any, timeout: number = 3 * 60 * 1000, timeoutText = '输入超时') {
+        const middleware: MessageMiddleware<P> = (event, next) => {
+            if (this.getChannelAddress<P>(event) !== this.getChannelAddress<P>(this.event)) return next();
+            callback(event.$raw);
+            dispose();
+            clearTimeout(timer);
+        };
+        const dispose = this.plugin.addMiddleware(middleware);
+        const timer = setTimeout(() => {
+            dispose();
+            callback(new Error(timeoutText));
+        }, timeout);
+    }
+    /**
+     * 文本输入
+     */
+    async text(tips: string, timeout?: number, defaultValue = '', timeoutText?: string): Promise<string> {
+        return this.prompt<string>({
+            tips,
+            defaultValue,
+            timeoutText,
+            timeout,
+            format: (input: string) => input,
+        });
+    }
+    /**
+     * 任意输入
+     */
+    async any(tips: string, timeout?: number, defaultValue = '', timeoutText?: string) {
+        return this.prompt<string>({
+            tips,
+            defaultValue,
+            timeoutText,
+            timeout,
+            format: (input: string) => input,
+        });
+    }
+    /**
+     * 数字输入
+     */
+    async number(tips: string, timeout?: number, defaultValue = 0, timeoutText?: string): Promise<number> {
+        return this.prompt<number>({
+            tips,
+            defaultValue,
+            timeoutText,
+            timeout,
+            format: (input: string) => +input,
+        });
+    }
+    /**
+     * 确认输入（如 yes/no）
+     */
+    async confirm(
+        tips: string,
+        condition: string = 'yes',
+        timeout?: number,
+        defaultValue = false,
+        timeoutText?: string,
+    ): Promise<boolean> {
+        return this.prompt<boolean>({
+            tips: `${tips}\n输入“${condition}”以确认`,
+            defaultValue,
+            timeout,
+            timeoutText,
+            format: (input: string) => input === condition,
+        });
+    }
+    /**
+     * 列表输入，支持多值分隔
+     */
+    async list<T extends Prompt.SingleType = 'text'>(
+        tips: string,
+        config: Prompt.ListConfig<T> = { type: 'text' as T },
+        timeoutText?: string,
+    ): Promise<Prompt.Result<T>[]> {
+        const separator = config.separator || ',';
+        return this.prompt<Prompt.Result<T>[]>({
+            tips: `${tips}\n值之间使用“${separator}”分隔`,
+            defaultValue: config.defaultValue || [],
+            timeout: config.timeout,
+            timeoutText,
+            format: (input: string) =>
+                input.split(separator).map(v => {
+                    switch (config.type) {
+                        case 'boolean':
+                            return Boolean(v);
+                        case 'number':
+                            return +v;
+                        case 'text':
+                            return v;
+                    }
+                }) as Prompt.Result<T>[],
+        });
+    }
+    /**
+     * 返回常量值（用于Schema）
+     */
+    async const<T = any>(value: T): Promise<T> {
+        return value;
+    }
+    /**
+     * 选项选择，支持单选/多选
+     */
+    async pick<T extends Prompt.SingleType, M extends boolean = false>(
+        tips: string,
+        config: Prompt.PickConfig<T, M>,
+        timeoutText?: string,
+    ): Promise<Prompt.PickResult<T, M>> {
+        const moreTextArr = config.options.map((o, idx) => {
+            return `${idx + 1}.${o.label}`;
+        });
+        const separator = config.separator || ',';
+        if (config.multiple) moreTextArr.push(`多选请用“${separator}”分隔`);
+        return this.prompt<Prompt.PickResult<T, M>>({
+            tips: `${tips}\n${moreTextArr.join('\n')}`,
+            defaultValue: config.defaultValue,
+            timeout: config.timeout,
+            timeoutText,
+            format: (input: string) => {
+                if (!config.multiple)
+                    return config.options.find((o, idx) => {
+                        return idx + 1 === +input;
+                    })?.value as Prompt.PickResult<T, M>;
+                const pickIdx = input.split(separator).map(Number);
+                return config.options
+                    .filter((o, idx) => {
+                        return pickIdx.includes(idx + 1);
+                    })
+                    .map(o => o.value) as Prompt.PickResult<T, M>;
+            },
+        });
+    }
+    /**
+     * 基于Schema的选项选择
+     */
+    async pickValueWithSchema<T extends Schema>(schema: T): Promise<Schema.Types<T>> {
+        return this.pick(schema.meta.description, {
+            type: '' as any,
+            options: schema.meta.options!.map(o => ({
+                label: o.label,
+                value: o.value,
+            })),
+            multiple: schema.meta.multiple,
+            defaultValue: schema.meta.default,
+        });
+    }
+    /**
+     * 批量Schema输入
+     */
+    async getValueWithSchemas<T extends Record<string, Schema>>(schemas: T): Promise<Schema.RecordTypes<T>> {
+        const result: Dict = {};
+        for (const key of Object.keys(schemas)) {
+            const schema = schemas[key];
+            result[key] = await this.getValueWithSchema(schema);
+        }
+        return result as Schema.RecordTypes<T>;
+    }
+    /**
+     * 单个Schema输入，自动分发到不同类型
+     */
+    async getValueWithSchema<T extends Schema>(schema: T): Promise<Schema.Types<T>> {
+        if (schema.meta.options) return this.pickValueWithSchema(schema);
+        switch (schema.meta.type) {
+            case 'number':
+                return (await this.number(schema.meta.description)) as Schema.Types<T>;
+            case 'string':
+                return (await this.text(schema.meta.description)) as Schema.Types<T>;
+            case 'boolean':
+                return (await this.confirm(schema.meta.description)) as Schema.Types<T>;
+            case 'object':
+                if (schema.meta.description) await this.event.$reply(schema.meta.description);
+                return (await this.getValueWithSchemas(schema.options.object!)) as Schema.Types<T>;
+            case 'date':
+                return await this.prompt({
+                    tips: schema.meta.description,
+                    defaultValue: schema.meta.default || new Date(),
+                    format: (input: string) => new Date(input) as Schema.Types<T>,
+                });
+            case 'regexp':
+                return await this.prompt({
+                    tips: schema.meta.description,
+                    defaultValue: schema.meta.default || '',
+                    format: (input: string) => new RegExp(input) as Schema.Types<T>,
+                });
+            case 'const':
+                return await this.const(schema.meta.default!);
+            case 'list':
+                const inner = schema.options.inner!;
+                if (!['string', 'boolean', 'number'].includes(inner.meta.type))
+                    throw new Error(`unsupported inner type :${inner.meta.type}`);
+                return (await this.list(schema.meta.description, {
+                    type: inner.meta.type === 'string' ? 'text' : (inner.meta.type as Prompt.SingleType),
+                    defaultValue: schema.meta.default,
+                })) as Schema.Types<T>;
+            case 'dict':
+            default:
+                throw new Error(`Unsupported schema input type: ${schema.meta.type}`);
+        }
+    }
+}
+/**
+ * Prompt命名空间：类型辅助定义
+ */
+export namespace Prompt {
+    interface SingleMap {
+        text: string;
+        number: number;
+        boolean: boolean;
+    }
+    export interface ListConfig<T extends SingleType> {
+        type: T;
+        defaultValue?: SingleMap[T][];
+        separator?: string;
+        timeout?: number;
+    }
+    export interface PickConfig<T extends SingleType = SingleType, M extends boolean = false> {
+        type: T;
+        defaultValue?: PickResult<T, M>;
+        separator?: string;
+        timeout?: number;
+        options: PickOption<T>[];
+        multiple?: M;
+    }
+    export type PickOption<T extends SingleType = 'text'> = {
+        label: string;
+        value: SingleMap[T];
+    };
+    export type PickResult<T extends SingleType, M extends boolean> = M extends true ? Result<T>[] : Result<T>;
+    export type SingleType = keyof SingleMap;
+    export type Result<T extends SingleType> = SingleMap[T];
+    export type Config<R = any> = {
+        tips: string;
+        defaultValue?: R;
+        timeout?: number;
+        timeoutText?: string;
+        format: (input: string) => R;
+    };
+}