@yumerijs/core 2.1.0 → 2.1.1

package/dist/config.d.ts

@@ -1,122 +1,31 @@
-/**
- * @time: 2025/05/24 12:18
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
-/**
- * 插件配置模式定义类
- * 用于描述插件配置项的类型、默认值、描述等信息
- */
-export declare class ConfigSchema {
-    /**
-     * 配置项类型
-     */
-    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
-    /**
-     * 默认值
-     */
-    default?: any;
-    /**
-     * 配置项描述
-     */
+export declare function fallback<T>(schema: Schema<T>, config: T): T;
+export declare class Schema<T = any> {
+    _type?: T;
+    type: string;
+    isRequired?: boolean;
     description?: string;
-    /**
-     * 是否必需
-     */
-    required?: boolean;
-    /**
-     * 枚举值列表（可选项）
-     */
-    enum?: any[];
-    /**
-     * 数组项类型定义（当type为array时使用）
-     */
-    items?: ConfigSchema;
-    /**
-     * 对象属性定义（当type为object时使用）
-     */
-    properties?: Record<string, ConfigSchema>;
-    /**
-     * 创建配置模式对象
-     * @param type 配置项类型
-     * @param options 配置项选项
-     */
-    constructor(type: 'string' | 'number' | 'boolean' | 'object' | 'array', options?: {
-        default?: any;
-        description?: string;
-        required?: boolean;
-        enum?: any[];
-        items?: ConfigSchema;
-        properties?: Record<string, ConfigSchema>;
+    defaultValue?: any;
+    properties?: Record<string, Schema<any>>;
+    items?: Schema<any>;
+    enum?: T[];
+    constructor(definition: Omit<Schema<T>, '_type' | 'required' | 'default'> & {
+        enum?: T[];
     });
-    /**
-     * 创建字符串类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static string(options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
-    /**
-     * 创建数字类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static number(options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
-    /**
-     * 创建布尔类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static boolean(options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
-    /**
-     * 创建对象类型配置模式
-     * @param properties 对象属性定义
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static object(properties: Record<string, ConfigSchema>, options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
-    /**
-     * 创建数组类型配置模式
-     * @param items 数组项类型定义
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static array(items: ConfigSchema, options?: Omit<ConfigSchema, 'type' | 'items' | 'properties'>): ConfigSchema;
+    static string(description?: string): Schema<string>;
+    static number(description?: string): Schema<number>;
+    static boolean(description?: string): Schema<boolean>;
+    static array<T>(inner: Schema<T>, description?: string): Schema<T[]>;
+    static object<T extends {}>(properties: {
+        [K in keyof T]: Schema<T[K]>;
+    }, description?: string): Schema<T>;
+    static extend<T extends {}, U extends {}>(base: Schema<T>, extension: {
+        [K in keyof U]: Schema<U[K]>;
+    }, description?: string): Schema<T & U>;
+    static enum<L extends string | number>(values: L[], description?: string): Schema<L>;
+    required(this: this): this;
+    default(this: this, value: T): this;
 }
-export declare class Config {
-    /**
-     * 配置名称
-     */
-    name: string;
-    /**
-     * 配置内容
-     */
-    content: {
-        [name: string]: any;
-    };
-    /**
-     * 配置模式
-     */
-    schema?: Record<string, ConfigSchema>;
-    /**
-     * 创建配置对象
-     * @param name 配置名称
-     * @param content 配置内容
-     * @param schema 配置模式
-     */
-    constructor(name: string, content?: {
-        [name: string]: any;
-    }, schema?: Record<string, ConfigSchema>);
-    /**
-     * 获取配置项值
-     * @param key 配置项键名
-     * @param defaultValue 默认值
-     * @returns 配置项值
-     */
-    get<T>(key: string, defaultValue?: T): T;
-    /**
-     * 设置配置项值
-     * @param key 配置项键名
-     * @param value 配置项值
-     */
-    set(key: string, value: any): void;
+export { Schema as ConfigSchema };
+export interface Config {
+    [key: string]: any;
 }

package/dist/config.js

@@ -1,151 +1,83 @@
 "use strict";
-/**
- * @time: 2025/05/24 12:18
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Config = exports.ConfigSchema = void 0;
-/**
- * 插件配置模式定义类
- * 用于描述插件配置项的类型、默认值、描述等信息
- */
-class ConfigSchema {
-    /**
-     * 配置项类型
-     */
+exports.ConfigSchema = exports.Schema = void 0;
+exports.fallback = fallback;
+function isNullable(value) {
+    return value === null || value === undefined;
+}
+function fallback(schema, config) {
+    if (!schema)
+        return config;
+    let result = config;
+    if (isNullable(result)) {
+        result = schema.defaultValue;
+    }
+    if (schema.type === 'object') {
+        if (typeof result !== 'object' || result === null) {
+            result = {};
+        }
+        for (const key in schema.properties) {
+            const innerSchema = schema.properties[key];
+            result[key] = fallback(innerSchema, result[key]);
+        }
+    }
+    else if (schema.type === 'array' && schema.items) {
+        if (!Array.isArray(result)) {
+            result = [];
+        }
+        result = result.map((item) => fallback(schema.items, item));
+    }
+    return result;
+}
+class Schema {
+    _type; // Phantom type
     type;
-    /**
-     * 默认值
-     */
-    default;
-    /**
-     * 配置项描述
-     */
+    isRequired;
     description;
-    /**
-     * 是否必需
-     */
-    required;
-    /**
-     * 枚举值列表（可选项）
-     */
-    enum;
-    /**
-     * 数组项类型定义（当type为array时使用）
-     */
-    items;
-    /**
-     * 对象属性定义（当type为object时使用）
-     */
+    defaultValue;
     properties;
-    /**
-     * 创建配置模式对象
-     * @param type 配置项类型
-     * @param options 配置项选项
-     */
-    constructor(type, options) {
-        this.type = type;
-        if (options) {
-            this.default = options.default;
-            this.description = options.description;
-            this.required = options.required;
-            this.enum = options.enum;
-            this.items = options.items;
-            this.properties = options.properties;
-        }
+    items;
+    enum;
+    constructor(definition) {
+        this.type = definition.type;
+        this.isRequired = definition.isRequired;
+        this.description = definition.description;
+        this.defaultValue = definition.defaultValue;
+        this.properties = definition.properties;
+        this.items = definition.items;
+        this.enum = definition.enum;
     }
-    /**
-     * 创建字符串类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static string(options) {
-        return new ConfigSchema('string', options);
+    static string(description) {
+        return new Schema({ type: 'string', description });
     }
-    /**
-     * 创建数字类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static number(options) {
-        return new ConfigSchema('number', options);
+    static number(description) {
+        return new Schema({ type: 'number', description });
     }
-    /**
-     * 创建布尔类型配置模式
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static boolean(options) {
-        return new ConfigSchema('boolean', options);
+    static boolean(description) {
+        return new Schema({ type: 'boolean', description });
     }
-    /**
-     * 创建对象类型配置模式
-     * @param properties 对象属性定义
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static object(properties, options) {
-        return new ConfigSchema('object', { ...options, properties });
+    static array(inner, description) {
+        return new Schema({ type: 'array', items: inner, description });
     }
-    /**
-     * 创建数组类型配置模式
-     * @param items 数组项类型定义
-     * @param options 配置项选项
-     * @returns 配置模式对象
-     */
-    static array(items, options) {
-        return new ConfigSchema('array', { ...options, items });
+    static object(properties, description) {
+        return new Schema({ type: 'object', properties, description });
     }
-}
-exports.ConfigSchema = ConfigSchema;
-class Config {
-    /**
-     * 配置名称
-     */
-    name = '';
-    /**
-     * 配置内容
-     */
-    content = {};
-    /**
-     * 配置模式
-     */
-    schema;
-    /**
-     * 创建配置对象
-     * @param name 配置名称
-     * @param content 配置内容
-     * @param schema 配置模式
-     */
-    constructor(name, content, schema) {
-        this.name = name;
-        this.content = content || {}; // 如果 content 是 undefined，则赋值为空对象
-        this.schema = schema;
+    static extend(base, extension, description) {
+        const combinedProperties = { ...base.properties, ...extension };
+        return new Schema({ type: 'object', properties: combinedProperties, description: description || base.description });
     }
-    /**
-     * 获取配置项值
-     * @param key 配置项键名
-     * @param defaultValue 默认值
-     * @returns 配置项值
-     */
-    get(key, defaultValue) {
-        if (this.content[key] !== undefined) {
-            return this.content[key];
-        }
-        // 如果有schema，尝试从schema中获取默认值
-        if (this.schema && this.schema[key] && this.schema[key].default !== undefined) {
-            return this.schema[key].default;
-        }
-        return defaultValue;
+    static enum(values, description) {
+        const type = typeof values[0] === 'string' ? 'string' : typeof values[0] === 'number' ? 'number' : 'string'; // Infer type based on first value
+        return new Schema({ type, enum: values, description });
+    }
+    required() {
+        this.isRequired = true;
+        return this;
     }
-    /**
-     * 设置配置项值
-     * @param key 配置项键名
-     * @param value 配置项值
-     */
-    set(key, value) {
-        this.content[key] = value;
+    default(value) {
+        this.defaultValue = value;
+        return this;
     }
 }
-exports.Config = Config;
+exports.Schema = Schema;
+exports.ConfigSchema = Schema;

package/dist/context.d.ts

@@ -2,9 +2,8 @@ import { Core } from './core';
 import { Route } from './route';
 import { HookHandler } from './hook';
 import { Middleware } from './middleware';
-import { Config } from './config';
 interface Plugin {
-    apply: (ctx: Context, config: Config) => Promise<void>;
+    apply: (ctx: Context, config: any) => any;
     disable: (ctx: Context) => Promise<void>;
     depend: Array<string>;
     provide: Array<string>;
@@ -102,7 +101,7 @@ export declare class Context {
      * @param plugin 插件实例
      * @param config 插件配置
      */
-    apply(plugin: Plugin, config: Config): Promise<void>;
+    apply(plugin: Plugin, config: any): Promise<void>;
     /**
      * 注册 i18n
      * @param content 内容（可以是嵌套对象或单个key）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yumerijs/core",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Core module for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",