@zhin.js/core 1.0.0 → 1.0.1

package/src/bot.ts

@@ -1,9 +1,30 @@
-import type {BotConfig, SendOptions} from "./types";
-
-export interface Bot<T extends BotConfig=BotConfig> {
-    config: T;
-    connected?: boolean;
-    connect():Promise<void>
-    disconnect():Promise<void>
-    sendMessage(options: SendOptions): Promise<void>
+import type {RegisteredAdapters, SendOptions,AdapterConfig} from "./types.js";
+import {Message} from "./message.js";
+/**
+ * Bot接口：所有平台机器人需实现的统一接口。
+ * 负责消息格式化、连接、断开、消息发送等。
+ * @template M 消息类型
+ * @template T 配置类型
+ */
+export interface Bot<M extends object={},T extends BotConfig=BotConfig> {
+    /** 机器人配置 */
+    $config: T;
+    /** 是否已连接 */
+    $connected?: boolean;
+    /** 格式化平台消息为标准Message结构 */
+    $formatMessage(message:M):Message<M>
+    /** 连接机器人 */
+    $connect():Promise<void>
+    /** 断开机器人 */
+    $disconnect():Promise<void>
+    /** 发送消息 */
+    $sendMessage(options: SendOptions): Promise<void>
+}
+/**
+ * Bot配置类型，所有平台机器人通用
+ */
+export interface BotConfig{
+    context:string
+    name:string
+    [key:string]:any
 }

package/src/command.ts

@@ -0,0 +1,50 @@
+import {MatchResult, SegmentMatcher} from "segment-matcher";
+import {AdapterMessage, RegisteredAdapters, SendContent} from "./types.js";
+import type {Message} from "./message.js";
+import {MaybePromise} from "@zhin.js/types";
+
+/**
+ * MessageCommand类：命令系统核心，基于segment-matcher实现。
+ * 支持多平台命令注册、作用域限制、参数解析、异步处理等。
+ */
+export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredAdapters> extends SegmentMatcher{
+    #callbacks:MessageCommand.Callback<T>[]=[];
+    #checkers:MessageCommand.Checker<T>[]=[]
+    /**
+     * 限定命令作用域（适配器名）
+     * @param scopes 适配器名列表
+     */
+    scope<R extends T>(...scopes:R[]):MessageCommand<R>{
+        this.#checkers.push((m)=>(scopes as string[]).includes(m.$adapter))
+        return this as MessageCommand<R>
+    }
+    /**
+     * 注册命令回调
+     * @param callback 命令处理函数
+     */
+    action(callback:MessageCommand.Callback<T>){
+        this.#callbacks.push(callback)
+        return this as MessageCommand<T>;
+    }
+    /**
+     * 处理消息，自动匹配命令并执行回调
+     * @param message 消息对象
+     * @returns 命令返回内容或undefined
+     */
+    async handle(message:Message<AdapterMessage<T>>):Promise<SendContent|undefined>{
+        for(const check of this.#checkers){
+            const result=await check(message)
+            if(!result) return;
+        }
+        const matched=this.match(message.$content);
+        if(!matched) return
+        for(const handler of this.#callbacks){
+            const result=await handler(message,matched)
+            if(result) return result
+        }
+    }
+}
+export namespace MessageCommand{
+    export type Callback<T extends keyof RegisteredAdapters>=(message:Message<AdapterMessage<T>>,result:MatchResult)=>MaybePromise<SendContent|void>;
+    export type Checker<T extends keyof RegisteredAdapters>=(message:Message<AdapterMessage<T>>)=>MaybePromise<boolean>
+}

package/src/component.ts

@@ -0,0 +1,318 @@
+import {getValueWithRuntime, compiler, segment} from './utils.js';
+import {Dict, SendContent, SendOptions} from './types.js';
+import {Message} from "./message.js";
+import {MaybePromise} from "@zhin.js/types";
+export const CapWithChild = Symbol('CapWithChild');
+export const CapWithClose = Symbol('CapWithClose');
+/**
+ * Component类：消息组件系统核心，支持模板渲染、属性解析、循环等。
+ * 用于自定义消息结构和复用UI片段。
+ * @template T 组件props类型
+ * @template D 组件data类型
+ * @template P 组件props配置类型
+ */
+export class Component<T = {}, D = {}, P = Component.Props<T>> {
+    [CapWithClose]: RegExp;
+    [CapWithChild]: RegExp;
+    $props: Component.PropConfig[] = [];
+    get name(){
+        return this.$options.name;
+    }
+    set name(value:string){
+        this.$options.name=value;
+    }
+    /**
+     * 构造函数：初始化组件，生成属性正则
+     * @param $options 组件配置项
+     */
+    constructor(private $options: Component.Options<T, D, P>) {
+        this.formatProps();
+        this[CapWithChild] = new RegExp(`<${$options.name}([^>]*)?>([^<])*?</${$options.name}>`);
+        this[CapWithClose] = new RegExp(`<${$options.name}([^>]*)?/>`);
+    }
+    /**
+     * 判断模板是否为自闭合标签
+     * @param template 模板字符串
+     */
+    isClosing(template: string) {
+        return this[CapWithClose].test(template);
+    }
+    /**
+     * 匹配组件标签
+     * @param template 模板字符串
+     * @returns 匹配到的标签内容
+     */
+    match(template: string) {
+        let [match] = this[CapWithChild].exec(template) || [];
+        if (match) return match;
+        [match] = this[CapWithClose].exec(template) || [];
+        return match;
+    }
+    /**
+     * 格式化props配置，生成props数组
+     */
+    private formatProps() {
+        for (const [key, value] of Object.entries(this.$options.props || {})) {
+            this.formatProp(key, value as any);
+        }
+    }
+
+    /**
+     * 格式化单个prop配置
+     * @param name 属性名
+     * @param value 类型或配置
+     */
+    private formatProp(name: string, value: Exclude<Component.PropConfig, 'name'> | Component.TypeConstruct) {
+        if (typeof value === 'function') {
+            return this.$props.push({
+                name,
+                type: value,
+                default: undefined,
+            });
+        }
+        return this.$props.push({
+            name,
+            type: value.type,
+            default: value.default,
+        });
+    }
+
+    parseProps(template: string) {
+        const result = Object.fromEntries(
+            this.$props.map(prop => {
+                const generateDefault = typeof prop.default === 'function' ? prop.default : () => prop.default;
+                return [prop.name, generateDefault()];
+            }),
+        );
+        const matchedArr = [...template.matchAll(/([a-zA-Z\-:]+)\s*=\s*(['"])(.*?)\2/g)].filter(Boolean);
+        if (!matchedArr.length) return result;
+        for (const [_, key, __, value] of matchedArr) {
+            Object.defineProperty(result, key, {
+                enumerable: true,
+                writable: false,
+                value,
+            });
+        }
+        return result;
+    }
+    parseChildren(template: string): string {
+        if (this.isClosing(template)) return '';
+        const matched = template.match(/<[^>]+>([^<]*?)<\/[^?]+>/);
+        if (!matched) return '';
+        return matched[1];
+    }
+    async render(template: string, context: Component.Context): Promise<SendContent> {
+        const props = this.parseProps(template);
+        const assignValue = () => {
+            for (const key of keys) {
+                if (!key.startsWith(':')) continue;
+                Object.defineProperty(props, key.slice(1), {
+                    value: getValueWithRuntime(Reflect.get(props, key), context.parent),
+                });
+                Reflect.deleteProperty(props, key);
+            }
+        };
+        const keys = Object.keys(props).map(key => {
+            const newKey = key.replace(/(\w)+-(\w)/g, function (_, char, later) {
+                return `${char}${later.toUpperCase()}`;
+            });
+            if (key !== newKey) {
+                Object.defineProperty(props, newKey, {
+                    value: Reflect.get(props, key),
+                    enumerable: true,
+                });
+                Reflect.deleteProperty(props, key);
+            }
+            return newKey;
+        });
+        assignValue();
+        const data = this.$options.data ? this.$options.data.apply(props as P) : ({} as D);
+        for (const key of keys) {
+            if (key === 'vFor') {
+                const { 'vFor': expression, 'v-for': _, ...rest } = props as any;
+                const { name, value, ...other } = Component.fixLoop(expression);
+                const list = value === '__loop__' ? other[value] : getValueWithRuntime(value, context);
+                const fnStr = `
+                const result=[];\n
+                for(const ${name} of list){\n
+                  result.push(render(props,{\n
+                    ...context,\n
+                    children:'',\n
+                    $origin:'${template.replace(/'/g, "'")}',
+                    parent:{\n
+                      ...context.parent,\n
+                      ${name}:list[${name}]
+                    }\n
+                  }))\n
+                }
+                return result;`;
+                const fn = new Function('render,list,props,context', fnStr);
+                const newTpl = template
+                    .replace(`v-for="${expression}"`, '')
+                    .replace(`v-for='${expression}'`, '')
+                    .replace(`vFor="${expression}"`, '')
+                    .replace(`vFor='${expression}'`, '');
+                return (await Promise.all(fn(this.render.bind(this), list, newTpl, context))).join('');
+            }
+            if (key === 'vIf') {
+                const needRender = getValueWithRuntime(Reflect.get(props as object, 'vIf'), context);
+                if (!needRender) return '';
+            }
+        }
+        context.children = this.parseChildren(template) || context.children;
+        const ctx = {
+            $slots: context.$slots || {},
+            ...props,
+            ...data,
+            $message: context.$message,
+            render: context.render,
+            parent: context,
+            children: context.children,
+        } as Component.Context<D & P>;
+        const result = segment.toString(await this.$options.render(props as P, ctx));
+        context.$root = context.$root.replace(context.$origin || template,result.includes('<')?segment.escape(result):result);
+        return context.render(context.$root, context);
+    }
+}
+export function defineComponent<P>(render: Component.Render<P, {}>, name?: string): Component<{}, {}, P>;
+export function defineComponent<T, D = {}, P = Component.Props<T>>(options: Component.Options<T, D>): Component<T, D, P>;
+export function defineComponent<T = {}, D = {}, P = Component.Props<T>>(options: Component.Options<T, D, P> | Component.Render<P, D>, name = options.name) {
+    if (typeof options === 'function')
+        options = {
+            name,
+            render: options,
+        };
+    return new Component(options);
+}
+
+export namespace Component {
+    export type TypeConstruct<T = any> = {
+        new (): T;
+        readonly prototype: T;
+    };
+    export type PropConfig<T extends TypeConstruct = TypeConstruct> = {
+        name: string;
+        type: T;
+        default: Prop<T>;
+    };
+
+    export interface Options<T, D, P = Props<T>> {
+        name: string;
+        props?: T;
+        data?: (this: P) => D;
+        render: Render<P, D>;
+    }
+
+    export type Context<T = {}> = {
+        $slots: Dict<Render<any, any>>;
+        $message: Message;
+        $origin?: string;
+        $root: string;
+        parent: Context;
+        render(template: string, context: Context): Promise<SendContent>;
+        children?: string;
+    } & T;
+    export type Render<P = {}, D = {}> = (props: P, context: Context<P & D>) => MaybePromise<SendContent>;
+    export type Props<T> = {
+        [P in keyof T]: Prop<T[P]>;
+    };
+    export type PropWithDefault<T> = {
+        type: T;
+        default?: DefaultValue<T>;
+    };
+    type DefaultValue<T> = T extends ObjectConstructor | ArrayConstructor ? () => Prop<T> : Prop<T>;
+    export type Prop<T> = T extends BooleanConstructor
+        ? boolean
+        : T extends StringConstructor
+            ? string
+            : T extends NumberConstructor
+                ? number
+                : T extends ArrayConstructor
+                    ? any[]
+                    : T extends ObjectConstructor
+                        ? Dict
+                        : T extends PropWithDefault<infer R>
+                            ? Prop<R>
+                            : unknown;
+    export const fixLoop = (loop: string) => {
+        let [_, name, value] = /(\S+)\sin\s(\S+)/.exec(loop) || [];
+        if (/\d+/.test(value))
+            value = `[${new Array(+value)
+                .fill(0)
+                .map((_, i) => i)
+                .join(',')}]`;
+        if (/^\[.+]$/.test(value)) {
+            return { name, value: '__loop__', __loop__: JSON.parse(value) };
+        }
+        return { name, value };
+    };
+
+    export async function render(componentMap:Map<string,Component>,options:SendOptions):Promise<SendOptions>{
+        if(!componentMap.size) return options;
+        const components=[
+            ...componentMap.values(),
+            Template,
+            Slot,
+        ]
+        const createContext = (runtime: Dict = {}, parent: Component.Context, $root: string): Component.Context => {
+            return {
+                $slots: {},
+                ...runtime,
+                $message: parent.$message,
+                $root,
+                parent,
+                render: (template: string, context) => {
+                    return renderWithRuntime(template, context, context.$root);
+                },
+            };
+        };
+        const renderWithRuntime = async (template: string, runtime: Dict, $root: string):Promise<SendContent> => {
+            const ctx = createContext(runtime, runtime as Component.Context, $root);
+            template = compiler(template, runtime);
+            for (const comp of components) {
+                const match = comp.match(template);
+                if (!match) continue;
+                return await comp.render(match, ctx);
+            }
+            return template;
+        };
+        const template=segment.toString(options.content);
+        const output=await renderWithRuntime(template, options, template)
+        const content=segment.from(output)
+        return {
+            ...options,
+            content
+        };
+    }
+
+    export const Template=defineComponent({
+        name: 'template',
+        render(props, context) {
+            const keys = Object.keys(props);
+            if (!keys.length) keys.push('#default');
+            for (const key of Object.keys(props)) {
+                if (key.startsWith('#')) {
+                    context.parent.$slots[key.slice(1)] = (async p => {
+                        return await context.render(context.children || '', { ...context, ...p });
+                    }) as Render;
+                }
+            }
+            return '';
+        },
+    })
+    export const Slot=defineComponent({
+        name: 'slot',
+        props: {
+            name: String,
+        },
+        render({ name, ...props }, context) {
+            name = name || 'default';
+            if (!context.parent) return '';
+            if (context.parent.$slots[name]) return context.parent.$slots[name](props, context) as string;
+            return context.children || '';
+        },
+    })
+}
+process.on('unhandledRejection',e=>{
+    // console.error 已替换为注释
+})

package/src/config.ts

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import { parse as parseToml } from 'toml';
 import { config as loadDotenv } from 'dotenv';
-import type { AppConfig,DefineConfig } from './types.js';
+import type {AppConfig, DefineConfig} from './types.js';
 
 export interface ConfigOptions {
   configPath?: string;
@@ -49,7 +49,7 @@ function replaceEnvVars(str: string): string {
     } else if (defaultValue !== undefined) {
       return defaultValue;
     } else {
-      console.warn(`环境变量 ${envName} 未定义，保持原值`);
+      // console.warn 已替换为注释
       return match;
     }
   });
@@ -131,7 +131,7 @@ function findConfigFile(cwd: string = process.cwd()): string | null {
     'zhin.config.yml', 
     'zhin.config.json',
     'zhin.config.toml',
-    'zhin.config.js',
+    'zhin.config.ts',
     'zhin.config.ts',
     // 然后查找 config.* 格式
     'config.yaml',
@@ -262,15 +262,12 @@ export function saveConfig(config: AppConfig, filePath: string): void {
  */
 export function createDefaultConfig(format: ConfigFormat = 'yaml'): AppConfig {
   return {
-    bots: [
-      {
-        name: 'onebot11',
-        context: 'onebot11',
-        url: '${ONEBOT_URL:-ws://localhost:8080}',
-        access_token: '${ONEBOT_ACCESS_TOKEN:-}'
-      }
-    ],
+    bots: [{
+      name: 'onebot11',
+      context: 'onebot11',
+      url: '${ONEBOT_URL:-ws://localhost:8080}'
+    }],
     plugin_dirs: ['./src/plugins', 'node_modules'],
-    plugins: []
+    plugins: [],
   };
 } 

package/src/cron.ts

@@ -0,0 +1,176 @@
+import { CronExpressionParser, CronExpression } from 'cron-parser';
+
+/**
+ * Cron 定时任务类
+ * 基于 cron-parser 实现的定时任务调度器
+ */
+export class Cron {
+  private expression: CronExpression;
+  private callback: () => void | Promise<void>;
+  private timeoutId?: NodeJS.Timeout;
+  private isRunning = false;
+  private isDisposed = false;
+
+  /**
+   * 创建一个新的 Cron 实例
+   * @param cronExpression - Cron 表达式 (例如: '0 0 * * *' 表示每天午夜执行)
+   * @param callback - 要执行的回调函数
+   */
+  constructor(cronExpression: string, callback: () => void | Promise<void>) {
+    try {
+      this.expression = CronExpressionParser.parse(cronExpression);
+      this.callback = callback;
+    } catch (error) {
+      throw new Error(`Invalid cron expression "${cronExpression}": ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * 启动定时任务
+   */
+  run(): void {
+    if (this.isDisposed) {
+      throw new Error('Cannot run a disposed cron job');
+    }
+
+    if (this.isRunning) {
+      return; // 已经在运行中
+    }
+
+    this.isRunning = true;
+    this.scheduleNext();
+  }
+
+  /**
+   * 停止定时任务
+   */
+  stop(): void {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = undefined;
+    }
+    this.isRunning = false;
+  }
+
+  /**
+   * 销毁定时任务，释放资源
+   */
+  dispose(): void {
+    this.stop();
+    this.isDisposed = true;
+  }
+
+  /**
+   * 获取下一次执行时间
+   */
+  getNextExecutionTime(): Date {
+    if (this.isDisposed) {
+      throw new Error('Cannot get next execution time for a disposed cron job');
+    }
+    
+    // 重置表达式到当前时间
+    this.expression.reset();
+    return this.expression.next().toDate();
+  }
+
+  /**
+   * 检查任务是否正在运行
+   */
+  get running(): boolean {
+    return this.isRunning;
+  }
+
+  /**
+   * 检查任务是否已被销毁
+   */
+  get disposed(): boolean {
+    return this.isDisposed;
+  }
+
+  /**
+   * 获取原始的 cron 表达式字符串
+   */
+  get cronExpression(): string {
+    return this.expression.stringify();
+  }
+
+  /**
+   * 调度下一次执行
+   */
+  private scheduleNext(): void {
+    if (!this.isRunning || this.isDisposed) {
+      return;
+    }
+
+    try {
+      // 重置到当前时间并获取下一次执行时间
+      this.expression.reset();
+      const nextDate = this.expression.next().toDate();
+      const now = new Date();
+      const delay = nextDate.getTime() - now.getTime();
+
+      // 如果延迟时间为负数或0，说明应该立即执行
+      if (delay <= 0) {
+        this.executeCallback();
+        return;
+      }
+
+      // 设置定时器
+      this.timeoutId = setTimeout(() => {
+        this.executeCallback();
+      }, delay);
+
+    } catch (error) {
+      console.error(`Error scheduling next cron execution: ${(error as Error).message}`);
+      // 如果出错，停止任务
+      this.stop();
+    }
+  }
+
+  /**
+   * 执行回调函数并调度下一次执行
+   */
+  private async executeCallback(): Promise<void> {
+    if (!this.isRunning || this.isDisposed) {
+      return;
+    }
+
+    try {
+      // 执行回调函数
+      await this.callback();
+    } catch (error) {
+      console.error(`Error executing cron callback: ${(error as Error).message}`);
+    }
+
+    // 调度下一次执行
+    this.scheduleNext();
+  }
+}
+
+/**
+ * Cron 表达式格式说明:
+ * 
+ * 标准格式: "秒 分 时 日 月 周"
+ * 
+ * 字段说明:
+ * - 秒: 0-59
+ * - 分: 0-59  
+ * - 时: 0-23
+ * - 日: 1-31
+ * - 月: 1-12 (或 JAN-DEC)
+ * - 周: 0-7 (0和7都表示周日，或 SUN-SAT)
+ * 
+ * 特殊字符:
+ * - 星号: 匹配任意值
+ * - 问号: 用于日和周字段，表示不指定值
+ * - 横线: 表示范围，如 1-5
+ * - 逗号: 表示列表，如 1,3,5
+ * - 斜杠: 表示步长，如 0/15 表示每15分钟
+ * 
+ * 常用示例:
+ * - "0 0 0 * * *": 每天午夜执行
+ * - "0 0/15 * * * *": 每15分钟执行  
+ * - "0 0 12 * * *": 每天中午12点执行
+ * - "0 0 0 1 * *": 每月1号午夜执行
+ * - "0 0 0 * * 0": 每周日午夜执行
+ */