@zhin.js/core 1.0.0 → 1.0.1

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;
+    };
+}

package/src/schema.ts

@@ -0,0 +1,273 @@
+import { isEmpty } from './utils.js';
+
+export class Schema<S = any, T = S> {
+    public [Symbol.toStringTag] = 'Schema';
+    constructor(
+        public meta: Schema.Meta<S, T>,
+        public options: Schema.Options = {},
+    ) {
+        const _this = this;
+        const schema = function (value?: S) {
+            const formatter = Schema.resolve(_this.meta.type);
+            if (!formatter) throw new Error(`type ${_this.meta.type} not found`);
+            return formatter.call(_this, value);
+        } as Schema<S, T>;
+        return new Proxy(schema, {
+            get(target, p: string | symbol, receiver: any): any {
+                return Reflect.get(_this, p, receiver);
+            },
+            set(target, p: string | symbol, value: any, receiver: any): boolean {
+                return Reflect.set(_this, p, value, receiver);
+            },
+        });
+    }
+    static fromJSON<S, T>(json: Schema.JSON<S, T>) {
+        const { object, inner, list, ...meta } = json;
+        const options: Schema.Options = {};
+        if (object)
+            options.object = Object.fromEntries(Object.entries(object).map(([key, value]) => [key, Schema.fromJSON(value)]));
+        if (inner) options.inner = Schema.fromJSON(inner);
+        return new Schema<S, T>(meta, options);
+    }
+    toJSON(): Record<string, any> {
+        return Object.fromEntries(
+            Object.entries({
+                ...this.meta,
+                default: typeof this.meta.default === 'function' ? this.meta.default() : this.meta.default,
+                inner: this.options.inner?.toJSON(),
+                dict: this.options.object
+                    ? Object.fromEntries(Object.entries(this.options.object || {}).map(([key, value]) => [key, value.toJSON()]))
+                    : undefined,
+            }).filter(([key, value]) => typeof value !== 'undefined'),
+        );
+    }
+    [Symbol.unscopables]() {
+        return {
+            options: true,
+            meta: true,
+        };
+    }
+    /** 设置是否必填 */
+    required(): this {
+        this.meta.required = true;
+        return this;
+    }
+    /** 是否隐藏 */
+    hidden(): this {
+        this.meta.hidden = true;
+        return this;
+    }
+    /** 设置描述 */
+    description(description: string): this {
+        this.meta.description = description;
+        return this;
+    }
+    /** 设置默认值 */
+    default(defaultValue: T): this {
+        this.meta.default = defaultValue;
+        return this;
+    }
+    /** 设置选项列表 */
+    option(list: (T | Schema.Option<T>)[]): this {
+        this.meta.options = Schema.formatOptionList(list);
+        return this;
+    }
+    /** 设置是否允许多选 */
+    multiple(): this {
+        if (this.meta.type !== 'list') throw new Error('multiple only support list type');
+        this.meta.multiple = true;
+        return this;
+    }
+    /** 声明一个数字类型 */
+    static number(description: string): Schema<number> {
+        return new Schema<number>({ type: 'number', description });
+    }
+    /** 声明一个字符串类型 */
+    static string(description: string): Schema<string> {
+        return new Schema<string>({ type: 'string', description });
+    }
+    /** 声明一个布尔类型 */
+    static boolean(description: string): Schema<boolean> {
+        return new Schema<boolean>({ type: 'boolean', description });
+    }
+    /** 声明一个正则类型 */
+    static regexp(description: string) {
+        return new Schema<RegExp | string, RegExp>({ type: 'regexp', description });
+    }
+    /** 声明一个日期类型 */
+    static date(description: string) {
+        return new Schema<Date | number, Date>({ type: 'date', description });
+    }
+    /** 声明一个字典类型 */
+    static dict<X extends Schema>(input: X, description: string) {
+        return new Schema<Record<string, Schema.Types<X>>>({ type: 'dict', description }, { inner: input });
+    }
+    static object<X extends Record<string, Schema>>(input: X, description: string = '') {
+        return new Schema<Schema.RecordTypes<X>>({ type: 'object', description }, { object: input });
+    }
+    /** 声明一个列表类型 */
+    static list<X extends Schema>(inner: X, description: string) {
+        return new Schema<Schema.Types<X>[]>({ type: 'list', description }, { inner });
+    }
+    /** 声明一个常量 */
+    static const<X extends string | number | boolean>(value: X, description: string) {
+        return new Schema<X>({ type: 'const', default: value as any, description });
+    }
+    static resolve<T extends string>(type: T): Schema.Formatter {
+        return Schema.formatters.get(type)!;
+    }
+    static extend<T extends string>(type: T, formatter: Schema.Formatter) {
+        Schema.formatters.set(type, formatter);
+    }
+}
+export interface Schema<S = any> {
+    (value?: S): S;
+}
+export namespace Schema {
+    export const formatters: Map<string, Formatter> = new Map<string, Formatter>();
+    export type Formatter<S = any, T = S> = (this: Schema, value: S) => T;
+    export type JSON<S = any, T = S> = Meta<S, T> & {
+        object?: Record<string, JSON>;
+        inner?: JSON;
+        list?: JSON[];
+    };
+    export interface Meta<S = any, T = S> {
+        hidden?: boolean;
+        type: string;
+        default?: T;
+        required?: boolean;
+        options?: Option<T>[];
+        multiple?: boolean;
+        description: string;
+        component?: string;
+        min?: number;
+        max?: number;
+        step?: number;
+    }
+    export interface Options {
+        object?: Record<string, Schema>;
+        inner?: Schema;
+    }
+    export type Types<T> = T extends Schema<infer S> ? S : never;
+    export type RecordTypes<T> = T extends Record<string, Schema>
+        ? {
+            [K in keyof T]?: Types<T[K]>;
+        }
+        : unknown;
+    export function checkDefault<T>(schema: Schema, value: T, fallback: T = value) {
+        if (isEmpty(value)) {
+            value = schema.meta.default || fallback;
+        }
+        const validateType = (schema: Schema, value: any) => {
+            switch (schema.meta.type) {
+                case 'string':
+                    if (!['string', 'undefined'].includes(typeof value)) throw new TypeError(`value is not a string`);
+                    break;
+                case 'number':
+                    if (!['number', 'undefined'].includes(typeof value)) throw new TypeError(`value is not a number`);
+                    break;
+                case 'boolean':
+                    if (!['boolean', 'undefined'].includes(typeof value)) throw new TypeError(`value is not a boolean`);
+                    break;
+                case 'regexp':
+                    if (!['string', 'undefined'].includes(typeof value) && !(value instanceof RegExp))
+                        throw new TypeError(`value is not a RegExp|string`);
+                    break;
+                case 'date':
+                    if (!['number', 'undefined'].includes(typeof value) && !(value instanceof Date))
+                        throw new TypeError(`value is not a Date|number`);
+                    if (value instanceof Date && isNaN(value.getTime())) throw new TypeError(`value is not a valid Date`);
+                    break;
+                case 'dict':
+                    if (!['object', 'undefined', 'null'].includes(typeof value)) throw new TypeError(`value is not a object`);
+                    break;
+                case 'object':
+                    if (!['object', 'undefined', 'null'].includes(typeof value)) throw new TypeError(`value is not a object`);
+                    break;
+                case 'list':
+                    if (typeof value !== 'undefined' && !Array.isArray(value)) throw new TypeError(`value is not a list`);
+                    break;
+                case 'const':
+                    if (typeof value !== 'undefined' && value !== schema.meta.default) throw new TypeError(`value is not const`);
+                    break;
+                default:
+                    throw new TypeError(`value is not a valid type`);
+            }
+        };
+        if (schema.meta.required && typeof value === 'undefined') throw new Error(`value is required`);
+        validateType(schema, value);
+        return value;
+    }
+    export type Option<T = any> = {
+        label: string;
+        value: T;
+    };
+    export function formatOptionList<T extends (any | Schema.Option)[]>(list: T): Schema.Option[] {
+        return list.map(item => {
+            if (typeof item === 'string') {
+                return {
+                    label: `${item}`,
+                    value: item,
+                } as Schema.Option;
+            }
+            return item as unknown as Schema.Option;
+        });
+    }
+}
+Schema.extend('number', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    return value;
+});
+Schema.extend('string', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    return value;
+});
+Schema.extend('boolean', function (this: Schema, value: any) {
+    return Schema.checkDefault(this, value);
+});
+Schema.extend('dict', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value, {});
+    return Object.fromEntries(
+        Object.entries(value).map(([key, schema]) => {
+            return [key, this.options.inner!(schema)];
+        }),
+    );
+});
+
+Schema.extend('object', function (this: Schema, value: any) {
+    const getDefault = (schema: Schema) => {
+        const result = Object.create(null);
+        for (const key in schema.options.object) {
+            result[key] = getDefault(schema.options.object[key]);
+        }
+        return result;
+    };
+    value = Schema.checkDefault(this, value, getDefault(this));
+    return Object.fromEntries(
+        Object.entries(value).map(([key, schema]) => {
+            return [key, this.options.object![key](schema)];
+        }),
+    );
+});
+Schema.extend('list', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value, []);
+    return value.map((item: any) => this.options.inner!(item));
+});
+Schema.extend('regexp', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    if (typeof value === 'string') {
+        return new RegExp(value);
+    }
+    return value;
+});
+Schema.extend('date', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    return new Date(value);
+});
+Schema.extend('const', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    if (value !== this.meta.default) {
+        throw new Error('const value not match');
+    }
+    return value;
+});

package/src/types-generator.ts

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { logger } from './logger.js';
+import { getLogger } from '@zhin.js/logger';
+
+const logger = getLogger('TypesGenerator');
 
 /**
  * 更新 tsconfig.json 的类型声明
@@ -48,7 +50,7 @@ export async function generateEnvTypes(cwd: string): Promise<void> {
             try {
                 tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf-8'));
             } catch (err) {
-                console.error(err)
+                // console.error 已替换为注释
                 logger.warn('⚠️ Failed to parse tsconfig.json, creating new one');
             }
         }
@@ -69,6 +71,8 @@ export async function generateEnvTypes(cwd: string): Promise<void> {
         fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2), 'utf-8');
         logger.info('✅ Updated TypeScript types configuration');
     } catch (error) {
-        logger.warn('⚠️ Failed to update TypeScript types:', error);
+        logger.warn('⚠️ Failed to update TypeScript types', { 
+            error: error instanceof Error ? error.message : String(error) 
+        });
     }
 }