@zhin.js/core 1.0.16 → 1.0.18

package/src/built/cron.ts

@@ -0,0 +1,140 @@
+/**
+ * Cron Context
+ * 管理所有插件注册的定时任务
+ */
+import { Cron } from "../cron.js";
+import { Context, Plugin, getPlugin } from "../plugin.js";
+
+/**
+ * CronContext 扩展方法类型
+ */
+export interface CronContextExtensions {
+  /** 添加定时任务 */
+  addCron(cron: Cron): () => void;
+}
+
+// 扩展 Plugin 接口
+declare module "../plugin.js" {
+  namespace Plugin {
+    interface Extensions extends CronContextExtensions {}
+    interface Contexts {
+      cron: CronService;
+    }
+  }
+}
+
+/**
+ * 定时任务服务数据
+ */
+export interface CronService {
+  /** 任务列表 */
+  readonly items: Cron[];
+  /** 按 ID/表达式 索引 */
+  readonly byName: Map<string, Cron>;
+  /** 添加任务 */
+  add(cron: Cron, pluginName: string): () => void;
+  /** 移除任务 */
+  remove(cron: Cron): boolean;
+  /** 按名称获取 */
+  get(id: string): Cron | undefined;
+  /** 停止所有任务 */
+  stopAll(): void;
+  /** 启动所有任务 */
+  startAll(): void;
+  /** 获取状态 */
+  getStatus(): Array<{
+    expression: string;
+    running: boolean;
+    nextExecution: Date | null;
+    plugin: string;
+  }>;
+}
+
+/**
+ * 创建定时任务 Context
+ */
+export function createCronService(): Context<'cron', CronContextExtensions> {
+  const items: Cron[] = [];
+  const byName = new Map<string, Cron>();
+  const pluginMap = new Map<Cron, string>();
+  
+  const value: CronService = {
+    items,
+    byName,
+    
+    add(cron, pluginName) {
+      items.push(cron);
+      byName.set(cron.id || cron.cronExpression, cron);
+      pluginMap.set(cron, pluginName);
+      // 自动启动
+      if (!cron.running) {
+        cron.run();
+      }
+      return () => value.remove(cron);
+    },
+    
+    remove(cron) {
+      const index = items.indexOf(cron);
+      if (index !== -1) {
+        // 自动停止
+        if (cron.running) {
+          cron.stop();
+        }
+        items.splice(index, 1);
+        byName.delete(cron.id || cron.cronExpression);
+        pluginMap.delete(cron);
+        return true;
+      }
+      return false;
+    },
+    
+    get(id) {
+      return byName.get(id);
+    },
+    
+    stopAll() {
+      for (const cron of items) {
+        if (cron.running) {
+          cron.stop();
+        }
+      }
+    },
+    
+    startAll() {
+      for (const cron of items) {
+        if (!cron.running && !cron.disposed) {
+          cron.run();
+        }
+      }
+    },
+    
+    getStatus() {
+      return items.map(cron => ({
+        expression: cron.cronExpression,
+        running: cron.running,
+        nextExecution: cron.running ? cron.getNextExecutionTime() : null,
+        plugin: pluginMap.get(cron) || 'unknown',
+      }));
+    }
+  };
+  
+  return {
+    name: 'cron',
+    description: '定时任务服务',
+    value,
+    
+    dispose() {
+      value.stopAll();
+    },
+    
+    extensions: {
+      addCron(cron: Cron) {
+        const plugin = getPlugin();
+        const dispose = value.add(cron, plugin.name);
+        plugin.onDispose(dispose);
+        return dispose;
+      }
+    }
+  };
+}
+

package/src/built/database.ts

@@ -0,0 +1,38 @@
+import { Registry,Definition,Databases,Database } from "@zhin.js/database";
+import { DatabaseConfig,Models } from "../types.js";
+import { defineContext,Plugin } from "../plugin.js";
+import { SystemLogDefinition } from "../models/system-log.js";
+import { UserDefinition } from "../models/user.js";
+declare module "../plugin" {
+    namespace Plugin {
+        interface Extensions {
+            defineModel<K extends keyof Models>(name: K, definition: Definition<Models[K]>): void;
+        }
+        interface Contexts {
+            database: Database<any,Models,any>;
+        }
+    }
+}
+export function defineDatabaseService<K extends keyof Databases>(config: DatabaseConfig<K>) {
+    const db = Registry.create<Models,K>(config.dialect, config,{
+        SystemLog: SystemLogDefinition,
+        User: UserDefinition,
+    });
+    return defineContext({
+        name: 'database',
+        description: '数据库服务',
+        mounted: async () => {
+            await db.start();
+            return db;
+        },
+        dispose: async () => {
+            await db.stop();
+        },
+        extensions: {
+            defineModel<K extends keyof Models>(this:Plugin,name: K, definition: Definition<Models[K]>) {
+                db.define(name, definition);
+                this.logger.debug(`Model "${String(name)}" defined by plugin "${this.name}"`);
+            }
+        },
+    });
+}

package/src/{permissions.ts → built/permission.ts}

@@ -1,15 +1,11 @@
-import { MaybePromise } from "@zhin.js/types";
-import { RegisteredAdapter } from "./types.js";
-import { Message } from "./message.js";
-import { AdapterMessage } from "./types.js";
-import { App } from "./app.js";
+import { MaybePromise, RegisteredAdapter, Message, AdapterMessage } from "@zhin.js/core";
 export type PermissionItem<T extends RegisteredAdapter = RegisteredAdapter> = {
     name: string | RegExp
     check: PermissionChecker<T>
 }
 export type PermissionChecker<T extends RegisteredAdapter = RegisteredAdapter> = (name: string, message: Message<AdapterMessage<T>>) => MaybePromise<boolean>
-export class Permissions extends Array<PermissionItem>{
-    constructor(private readonly app: App) {
+export class PermissionService extends Array<PermissionItem>{
+    constructor() {
         super();
         this.add(Permissions.define(/^adapter\([^)]+\)$/, (name, message) => {
             return message.$adapter === name.replace(/^adapter\(([^)]+)\)$/, '$1');
@@ -48,11 +44,12 @@ export class Permissions extends Array<PermissionItem>{
     add(permission: PermissionItem) {
         this.push(permission);
     }
-    get(name: string): PermissionItem | undefined {
-        return this.app.dependencyList.reduce((result,dep)=>{
-            result.push(...dep.permissions)
-            return result;
-        },[...this]).find(p => new RegExp(p.name).test(name));
+    async check(name: string, message: Message<AdapterMessage<RegisteredAdapter>>):Promise<boolean> {
+        for(const permission of this){
+            const passed=await permission.check(name,message);
+            if(passed) return true;
+        }
+        return false;
     }
 }
 export namespace Permissions{

package/src/command.ts

@@ -1,19 +1,48 @@
 import {MatchResult, SegmentMatcher} from "segment-matcher";
 import {AdapterMessage, SendContent} from "./types.js";
-import {RegisteredAdapters} from "@zhin.js/types";
+import {RegisteredAdapter} from "./types.js";
 import type {Message} from "./message.js";
-import {MaybePromise} from "@zhin.js/types";
-import { ZhinError } from "./errors.js";
-import { App } from "./app.js";
+import {MaybePromise} from "./types.js";
+import {Plugin} from "./plugin.js";
 
 /**
  * MessageCommand类：命令系统核心，基于segment-matcher实现。
  * 支持多平台命令注册、作用域限制、参数解析、异步处理等。
  */
-export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredAdapters> extends SegmentMatcher{
+export class MessageCommand<T extends RegisteredAdapter=RegisteredAdapter> extends SegmentMatcher{
     #callbacks:MessageCommand.Callback<T>[]=[];
+    #desc:string[]=[];
+    #usage:string[]=[];
+    #examples:string[]=[];
     #permissions:string[]=[];
-    #checkers:MessageCommand.Checker<T>[]=[]
+    get helpInfo():MessageCommand.HelpInfo{
+        return {
+            pattern: this.pattern,
+            desc: this.#desc,
+            usage: this.#usage,
+            examples: this.#examples
+        }
+    }
+    get help(){
+        return [
+            this.pattern,
+            ...this.#desc,
+            ...this.#usage,
+            ...this.#examples
+        ].join("\n");
+    }
+    desc(...desc:string[]){
+        this.#desc.push(...desc)
+        return this as MessageCommand<T>;
+    }
+    usage(...usage:string[]){
+        this.#usage.push(...usage)
+        return this as MessageCommand<T>;
+    }
+    examples(...examples:string[]){
+        this.#examples.push(...examples)
+        return this as MessageCommand<T>;
+    }
     /**
      * 注册命令回调
      * @param callback 命令处理函数
@@ -32,18 +61,11 @@ export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredA
      * @param plugin 插件实例
      * @returns 命令返回内容或undefined
      */
-    async handle(message:Message<AdapterMessage<T>>,app:App):Promise<SendContent|undefined>{
-        for(const permission of this.#permissions){
-            const permit=app.permissions.get(permission)
-            if(!permit) {
-                throw new ZhinError(`权限 ${permission} 不存在`)
-            }
-            const result=await permit.check(permission,message)
-            if(!result) return;
-        }
-        for(const check of this.#checkers){
-            const result=await check(message)
-            if(!result) return;
+    async handle(message:Message<AdapterMessage<T>>,plugin:Plugin):Promise<SendContent|undefined>{
+        const auth = plugin.contextIsReady('permission') ? plugin.inject('permission') : null
+        for(const permit of this.#permissions){
+            const passed=await auth?.check(permit,message)
+            if(!passed) return;
         }
         const matched=this.match(message.$content);
         if(!matched) return
@@ -54,6 +76,12 @@ export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredA
     }
 }
 export namespace MessageCommand{
-    export type Callback<T extends keyof RegisteredAdapters>=(message:Message<AdapterMessage<T>>,result:MatchResult)=>SendContent|undefined|Promise<SendContent|undefined>;
-    export type Checker<T extends keyof RegisteredAdapters>=(message:Message<AdapterMessage<T>>)=>MaybePromise<boolean>
+    export type Callback<T extends RegisteredAdapter>=(message:Message<AdapterMessage<T>>,result:MatchResult)=>SendContent|undefined|Promise<SendContent|undefined>;
+    export type Checker<T extends RegisteredAdapter>=(message:Message<AdapterMessage<T>>)=>MaybePromise<boolean>
+    export type HelpInfo={
+        pattern:string;
+        desc:string[];
+        usage:string[];
+        examples:string[];
+    }
 }

package/src/component.ts

@@ -1,6 +1,5 @@
 import { getValueWithRuntime, compiler, segment } from './utils.js';
 import { Dict, SendContent, SendOptions, MessageElement } from './types.js';
-import { Message } from "./message.js";
 
 // 组件匹配符号
 export const CapWithChild = Symbol('CapWithChild');
@@ -8,7 +7,7 @@ export const CapWithClose = Symbol('CapWithClose');
 
 // 函数式组件类型定义
 export type Component<P = any> = {
-    (props: P, context: ComponentContext): Promise<SendContent>;
+    (props: P, context: ComponentContext): SendContent | Promise<SendContent>;
     name: string;
 }
 
@@ -562,4 +561,4 @@ export const Fragment = defineComponent(async (props: { children?: SendContent }
 }, 'Fragment');
 export const Fetch = defineComponent(async ({ url }) => {
     return await fetch(url).then((r) => r.text());
-}, 'fetch');
+}, 'fetch');

package/src/cron.ts

@@ -1,15 +1,15 @@
-import { CronExpressionParser, CronExpression } from 'cron-parser';
+import { Cron as Croner } from 'croner';
 
 /**
  * Cron 定时任务类
- * 基于 cron-parser 实现的定时任务调度器
+ * 基于 croner 实现的定时任务调度器 (无需 Luxon，内存占用更小)
  */
 export class Cron {
-  private expression: CronExpression;
+  private job: Croner | null = null;
+  id:string = '';
   private callback: () => void | Promise<void>;
-  private timeoutId?: NodeJS.Timeout;
-  private isRunning = false;
   private isDisposed = false;
+  private _cronExpression: string;
 
   /**
    * 创建一个新的 Cron 实例
@@ -17,9 +17,14 @@ export class Cron {
    * @param callback - 要执行的回调函数
    */
   constructor(cronExpression: string, callback: () => void | Promise<void>) {
+    this.id=Math.random().toString(36).substring(2, 10);
     try {
-      this.expression = CronExpressionParser.parse(cronExpression);
+      this._cronExpression = cronExpression;
       this.callback = callback;
+      
+      // 验证 cron 表达式是否有效 (不启动)
+      const testJob = new Croner(cronExpression, { paused: true });
+      testJob.stop();
     } catch (error) {
       throw new Error(`Invalid cron expression "${cronExpression}": ${(error as Error).message}`);
     }
@@ -33,23 +38,28 @@ export class Cron {
       throw new Error('Cannot run a disposed cron job');
     }
 
-    if (this.isRunning) {
+    if (this.job) {
       return; // 已经在运行中
     }
 
-    this.isRunning = true;
-    this.scheduleNext();
+    // 创建并启动任务
+    this.job = new Croner(this._cronExpression, async () => {
+      try {
+        await this.callback();
+      } catch (error) {
+        console.error(`Error executing cron callback: ${(error as Error).message}`);
+      }
+    });
   }
 
   /**
    * 停止定时任务
    */
   stop(): void {
-    if (this.timeoutId) {
-      clearTimeout(this.timeoutId);
-      this.timeoutId = undefined;
+    if (this.job) {
+      this.job.stop();
+      this.job = null;
     }
-    this.isRunning = false;
   }
 
   /**
@@ -68,16 +78,23 @@ export class Cron {
       throw new Error('Cannot get next execution time for a disposed cron job');
     }
     
-    // 重置表达式到当前时间
-    this.expression.reset();
-    return this.expression.next().toDate();
+    // 创建临时任务来获取下次执行时间
+    const tempJob = new Croner(this._cronExpression, { paused: true });
+    const nextRun = tempJob.nextRun();
+    tempJob.stop();
+    
+    if (!nextRun) {
+      throw new Error('Cannot determine next execution time');
+    }
+    
+    return nextRun;
   }
 
   /**
    * 检查任务是否正在运行
    */
   get running(): boolean {
-    return this.isRunning;
+    return this.job !== null;
   }
 
   /**
@@ -91,59 +108,7 @@ export class Cron {
    * 获取原始的 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();
+    return this._cronExpression;
   }
 }
 

package/src/index.ts

@@ -1,18 +1,28 @@
 // Core exports
-export * from './app.js'
 export * from './bot.js'
 export * from './plugin.js'
 export * from './command.js'
 export * from './component.js'
 export * from './adapter.js'
-export * from './config.js'
 export * from './message.js'
-// Logger moved to @zhin.js/logger package
+export * from './prompt.js'
+// Models
+export * from './models/system-log.js'
+export * from './models/user.js'
+// Built-in Contexts
+export * from './built/config.js'
+export * from './built/command.js'
+export * from './built/cron.js'
+export * from './built/permission.js'
+export * from './built/adapter-process.js'
+export * from './built/component.js'
+export * from './built/database.js'
+
 export * from './types.js'
 export * from './utils.js'
 export * from './errors.js'  // 导出错误处理系统
 export * from './cron.js'
 export * from '@zhin.js/database'
 export * from '@zhin.js/logger'
-
-export { Dependency, Schema } from '@zhin.js/hmr'
+// 只导出 Schema 类，避免与 utils.js 的 isEmpty 冲突
+export { Schema } from '@zhin.js/schema'

package/src/jsx.ts

@@ -1,4 +1,3 @@
-import { MaybePromise } from '@zhin.js/types';
 import { SendContent,MessageElement } from './types.js';
 import { MessageComponent } from './message.js';
 import { Component, ComponentContext } from './component.js';
@@ -20,9 +19,9 @@ declare global {
     namespace JSX {
         // 支持同步和异步组件 - Element 可以是 MessageComponent
         // TypeScript 会在编译时允许异步组件，运行时会自动 await
-        type Element = MessageComponent<any> | Promise<MessageComponent<any>> | Promise<SendContent>
+        type Element = SendContent | Promise<SendContent>
         interface ElementClass {
-            render(props: any, context?: ComponentContext): MaybePromise<SendContent>;
+            render(props: any, context?: ComponentContext): Element;
         }
         interface ElementAttributesProperty {
             data: {};

package/src/message.ts

@@ -1,12 +1,11 @@
-import {MessageElement, MessageSender, SendContent} from "./types";
+import {MessageElement, MessageSender, RegisteredAdapter, SendContent} from "./types";
 import { Component } from "./component.js";
 
 /**
  * 消息组件类型：用于自定义消息结构
- * 支持同步和异步组件
  */
 export type MessageComponent<T extends object>={
-    type:Component<T&{children?:SendContent}> | ((props: T & {children?: SendContent}) => Promise<SendContent>)
+    type:Component<T&{children?:SendContent|Promise<SendContent>}>
     data:T
 }
 /**
@@ -25,7 +24,7 @@ export type MessageType = 'group' | 'private' | 'channel'
  */
 export interface MessageBase {
     $id: string;
-    $adapter:string
+    $adapter:RegisteredAdapter
     $bot:string
     $content: MessageElement[];
     $sender: MessageSender;