@yunzai-ng/core 0.1.0

package/dist/config/schema.js

@@ -0,0 +1,871 @@
+var _a;
+import { deepClone, isPlainObject } from "../util/deep.js";
+import { parseDuration } from "../util/duration.js";
+/** 校验失败抛出的错误 */
+export class SchemaError extends Error {
+    /** 错误名 */
+    name = "SchemaError";
+    /** 全部问题 */
+    issues;
+    /**
+     * @param issues 校验问题列表
+     */
+    constructor(issues) {
+        const lines = issues
+            .filter(i => i.severity === "error")
+            .map(i => `  · ${i.path === "" ? "(根)" : i.path}：${i.message}`);
+        super(`配置校验失败：\n${lines.join("\n")}`);
+        this.issues = issues;
+    }
+}
+/** 校验失败的哨兵值 */
+const INVALID = Symbol("invalid");
+/**
+ * 配置 schema 节点
+ *
+ * 不可变：全部 fluent 方法均返回新实例，因此可安全地抽取公共片段以供复用。
+ */
+export class Schema {
+    /** 内部定义 */
+    #def;
+    /**
+     * @param def 内部定义；请通过 `s.*` 工厂函数创建，不要直接 new
+     */
+    constructor(def) {
+        this.#def = def;
+    }
+    /* ───────────────────────────── 元信息 ───────────────────────────── */
+    /**
+     * 设置表单标签
+     * @param text 标签文案
+     * @returns 新 schema
+     */
+    title(text) {
+        return this.#patch({ meta: { title: text } });
+    }
+    /**
+     * 设置说明文案
+     * @param text 说明
+     * @returns 新 schema
+     */
+    desc(text) {
+        return this.#patch({ meta: { description: text } });
+    }
+    /**
+     * 设置分组（WebUI 折叠区块）
+     * @param name 分组名
+     * @returns 新 schema
+     */
+    group(name) {
+        return this.#patch({ meta: { group: name } });
+    }
+    /**
+     * 设置排序权重，小的在前
+     * @param weight 权重
+     * @returns 新 schema
+     */
+    order(weight) {
+        return this.#patch({ meta: { order: weight } });
+    }
+    /**
+     * 指定控件类型
+     * @param widget 控件
+     * @returns 新 schema
+     */
+    widget(widget) {
+        return this.#patch({ meta: { widget } });
+    }
+    /**
+     * 标记为敏感字段
+     *
+     * WebUI 读取时脱敏、日志中不打印。CK、token、密码必须标。
+     * @returns 新 schema
+     */
+    secret() {
+        return this.#patch({ meta: { secret: true, widget: this.#def.meta.widget ?? "password" } });
+    }
+    /**
+     * 标记为只读
+     * @returns 新 schema
+     */
+    readonly() {
+        return this.#patch({ meta: { readonly: true } });
+    }
+    /**
+     * 设置输入框占位符
+     * @param text 占位文案
+     * @returns 新 schema
+     */
+    placeholder(text) {
+        return this.#patch({ meta: { placeholder: text } });
+    }
+    /**
+     * 设置条件显隐
+     * @param cond 同级字段取值条件，如 `{ mode: "ws-reverse" }`；值写成数组表示"取其中之一"
+     * @returns 新 schema
+     */
+    showWhen(cond) {
+        return this.#patch({ meta: { showWhen: cond } });
+    }
+    /* ───────────────────────────── 可选与默认 ───────────────────────────── */
+    /**
+     * 标记为可缺省
+     * @returns 新 schema，输出类型带上 undefined
+     */
+    optional() {
+        return this.#patch({ optional: true });
+    }
+    /**
+     * 设置默认值
+     *
+     * 有默认值的字段在输出类型里仍是必填 —— 因为解析后一定有值。
+     * @param value 默认值
+     * @returns 新 schema
+     */
+    default(value) {
+        return this.#patch({ hasDefault: true, defaultValue: value });
+    }
+    /**
+     * 追加自定义校验
+     * @param message 不通过时的中文提示
+     * @param test 返回 true 表示通过
+     * @returns 新 schema
+     */
+    check(message, test) {
+        const checks = [...(this.#def.checks ?? []), { message, test: test }];
+        return this.#patch({ checks });
+    }
+    /* ───────────────────────────── 约束 ───────────────────────────── */
+    /**
+     * 下界：数值最小值 / 字符串最短长度 / 数组最少元素
+     * @param value 下界
+     * @returns 新 schema
+     */
+    min(value) {
+        return this.#patch({ min: value });
+    }
+    /**
+     * 上界：数值最大值 / 字符串最长长度 / 数组最多元素
+     * @param value 上界
+     * @returns 新 schema
+     */
+    max(value) {
+        return this.#patch({ max: value });
+    }
+    /**
+     * 字符串正则约束
+     * @param regex 正则
+     * @param message 自定义提示
+     * @returns 新 schema
+     */
+    pattern(regex, message) {
+        const next = this.#patch({ pattern: regex });
+        return message ? next.check(message, v => typeof v !== "string" || regex.test(v)) : next;
+    }
+    /**
+     * 要求整数
+     * @returns 新 schema
+     */
+    int() {
+        return this.#patch({ int: true, step: this.#def.step ?? 1 });
+    }
+    /**
+     * 数值步长（表单提示用）
+     * @param value 步长
+     * @returns 新 schema
+     */
+    step(value) {
+        return this.#patch({ step: value });
+    }
+    /**
+     * 对象：拒绝未识别的键
+     *
+     * 缺省行为是"保留并 warn"，适配器这类结构明确的配置可以开严格模式。
+     * @returns 新 schema
+     */
+    strict() {
+        return this.#patch({ strict: true });
+    }
+    /**
+     * 数组：允许单值自动包成数组
+     *
+     * 让 `masterQQ: 123` 与 `masterQQ: [123]` 都能用 —— 旧配置最常见的困惑点。
+     * @returns 新 schema
+     */
+    single() {
+        return this.#patch({ wrapSingle: true });
+    }
+    /* ───────────────────────────── 解析 ───────────────────────────── */
+    /**
+     * 解析并校验
+     * @param input 待校验值
+     * @returns 结果对象；失败时带全部问题，不抛错
+     */
+    safeParse(input) {
+        const issues = [];
+        const value = this.#validate(input, "", issues);
+        const failed = value === INVALID || issues.some(i => i.severity === "error");
+        return failed ? { ok: false, issues } : { ok: true, value: value, issues };
+    }
+    /**
+     * 解析并校验，失败抛错
+     * @param input 待校验值
+     * @returns 校验后的值（已填默认、已强制转换）
+     * @throws SchemaError 校验失败
+     */
+    parse(input) {
+        const result = this.safeParse(input);
+        if (!result.ok)
+            throw new SchemaError(result.issues);
+        return result.value;
+    }
+    /**
+     * 只取默认值，不需要输入
+     *
+     * 用于生成初始配置文件。
+     * @returns 全部默认值构成的对象
+     * @throws SchemaError 当 schema 里有无默认值的必填项
+     */
+    defaults() {
+        return this.parse(undefined);
+    }
+    /**
+     * 降级为 WebUI 表单描述
+     * @returns 表单描述结构体
+     */
+    describe() {
+        const def = this.#def;
+        const out = { type: this.#descriptorType() };
+        if (def.meta.title !== undefined)
+            out.title = def.meta.title;
+        if (def.meta.description !== undefined)
+            out.description = def.meta.description;
+        if (def.hasDefault)
+            out.default = deepClone(def.defaultValue);
+        if (!def.optional && !def.hasDefault)
+            out.required = true;
+        if (def.meta.secret)
+            out.secret = true;
+        if (def.meta.readonly)
+            out.readonly = true;
+        if (def.meta.widget !== undefined)
+            out.widget = def.meta.widget;
+        if (def.meta.group !== undefined)
+            out.group = def.meta.group;
+        if (def.meta.order !== undefined)
+            out.order = def.meta.order;
+        if (def.meta.placeholder !== undefined)
+            out.placeholder = def.meta.placeholder;
+        if (def.meta.showWhen !== undefined)
+            out.showWhen = def.meta.showWhen;
+        if (def.min !== undefined)
+            out.min = def.min;
+        if (def.max !== undefined)
+            out.max = def.max;
+        if (def.step !== undefined)
+            out.step = def.step;
+        if (def.pattern !== undefined)
+            out.pattern = def.pattern.source;
+        if (def.kind === "object" && def.shape) {
+            const properties = {};
+            for (const [key, child] of Object.entries(def.shape))
+                properties[key] = child.describe();
+            out.properties = properties;
+        }
+        if (def.kind === "array" && def.element)
+            out.items = def.element.describe();
+        if (def.kind === "record" && def.valueSchema)
+            out.values = def.valueSchema.describe();
+        if (def.kind === "enum" && def.enumItems)
+            out.enum = def.enumItems.map(item => ({ ...item }));
+        if (def.kind === "literal")
+            out.enum = [{ value: def.literalValue }];
+        return out;
+    }
+    /**
+     * 对象 schema：取子字段 schema
+     * @param key 字段名
+     * @returns 子 schema；不是对象或字段不存在时 undefined
+     */
+    /**
+     *
+     */
+    field(key) {
+        return this.#def.shape?.[key];
+    }
+    /**
+     * 收集全部标了 `secret()` 的字段路径
+     *
+     * 日志脱敏与 WebUI 读取脱敏都用它，保证"标一次、处处生效"。
+     * @returns 点分路径列表
+     */
+    secretPaths() {
+        const out = [];
+        this.#collectSecrets("", out);
+        return out;
+    }
+    /* ───────────────────────────── 内部 ───────────────────────────── */
+    /**
+     * 克隆并打补丁
+     * @param patch 要覆盖的定义片段
+     * @returns 新 schema
+     */
+    #patch(patch) {
+        return new _a({
+            ...this.#def,
+            ...patch,
+            meta: { ...this.#def.meta, ...(patch.meta ?? {}) }
+        });
+    }
+    /**
+     * 映射到表单描述的类型名
+     * @returns 描述类型
+     */
+    #descriptorType() {
+        switch (this.#def.kind) {
+            case "literal":
+                return "enum";
+            case "string":
+            case "number":
+            case "boolean":
+            case "enum":
+            case "array":
+            case "object":
+            case "record":
+                return this.#def.kind;
+            default:
+                return "unknown";
+        }
+    }
+    /**
+     * 递归收集敏感字段路径
+     * @param prefix 当前路径前缀
+     * @param out 收集容器
+     */
+    #collectSecrets(prefix, out) {
+        if (this.#def.meta.secret)
+            out.push(prefix);
+        if (this.#def.shape) {
+            for (const [key, child] of Object.entries(this.#def.shape)) {
+                child.#collectSecrets(prefix === "" ? key : `${prefix}.${key}`, out);
+            }
+        }
+        if (this.#def.element)
+            this.#def.element.#collectSecrets(prefix === "" ? "*" : `${prefix}.*`, out);
+        if (this.#def.valueSchema)
+            this.#def.valueSchema.#collectSecrets(prefix === "" ? "*" : `${prefix}.*`, out);
+    }
+    /**
+     * 记录一条问题
+     * @param issues 收集容器
+     * @param path 路径
+     * @param message 说明
+     * @param severity 严重程度
+     */
+    #fail(issues, path, message, severity = "error") {
+        issues.push({ path, message, severity });
+    }
+    /**
+     * 核心校验
+     * @param input 输入值
+     * @param path 当前路径
+     * @param issues 问题收集容器
+     * @returns 校验后的值，或 INVALID
+     */
+    #validate(input, path, issues) {
+        const def = this.#def;
+        // 缺失值处理：默认值 → 可选 → 对象自动物化 → 报缺失
+        if (input === undefined || input === null) {
+            if (def.hasDefault)
+                return this.#materializeDefault(path, issues);
+            if (def.optional)
+                return undefined;
+            if (def.kind === "object")
+                return this.#validateObject({}, path, issues);
+            if (def.kind === "unknown")
+                return undefined;
+            this.#fail(issues, path, "缺少必填项");
+            return INVALID;
+        }
+        let value;
+        switch (def.kind) {
+            case "string":
+                value = this.#validateString(input, path, issues);
+                break;
+            case "number":
+                value = this.#validateNumber(input, path, issues);
+                break;
+            case "boolean":
+                value = this.#validateBoolean(input, path, issues);
+                break;
+            case "enum":
+                value = this.#validateEnum(input, path, issues);
+                break;
+            case "literal":
+                value = input === def.literalValue ? input : this.#reject(issues, path, `必须为 ${String(def.literalValue)}`);
+                break;
+            case "array":
+                value = this.#validateArray(input, path, issues);
+                break;
+            case "object":
+                value = this.#validateObject(input, path, issues);
+                break;
+            case "record":
+                value = this.#validateRecord(input, path, issues);
+                break;
+            default:
+                value = input;
+        }
+        if (value === INVALID)
+            return INVALID;
+        for (const rule of def.checks ?? []) {
+            if (!rule.test(value)) {
+                this.#fail(issues, path, rule.message);
+                return INVALID;
+            }
+        }
+        return value;
+    }
+    /**
+     * 记录错误并返回 INVALID
+     * @param issues 问题收集容器
+     * @param path 路径
+     * @param message 说明
+     * @returns INVALID
+     */
+    #reject(issues, path, message) {
+        this.#fail(issues, path, message);
+        return INVALID;
+    }
+    /**
+     * 把声明的默认值也过一遍校验
+     *
+     * 默认值必须走同一条校验/转换链，否则 `defaults()` 与 `parse(用户文件)`
+     * 会给出**形态不同的同一份配置**（例如 duration 的默认 `0` 与文件里读回的
+     * `"0"`），下游按路径比对时就会在每次启动时误报"配置变了"。
+     *
+     * 默认值不合法属于插件作者的 bug，不是用户的错：这里只记 warn 并退回原始
+     * 默认值，让机器人照常启动，而不是让用户面对一个自己无法修复的启动失败。
+     * @param path 当前路径
+     * @param issues 问题收集容器
+     * @returns 规范化后的默认值
+     */
+    #materializeDefault(path, issues) {
+        const raw = deepClone(this.#def.defaultValue);
+        if (raw === undefined || raw === null)
+            return raw;
+        const probe = [];
+        const value = this.#validate(raw, path, probe);
+        if (value === INVALID || probe.some(i => i.severity === "error")) {
+            const detail = probe.map(i => i.message).join("；");
+            issues.push({
+                path,
+                message: `schema 声明的默认值不符合自身规则（${detail}），请联系插件作者`,
+                severity: "warn"
+            });
+            return raw;
+        }
+        issues.push(...probe);
+        return value;
+    }
+    /**
+     * 校验字符串
+     * @param input 输入
+     * @param path 路径
+     * @param issues 问题容器
+     * @returns 字符串或 INVALID
+     */
+    #validateString(input, path, issues) {
+        const def = this.#def;
+        // 数字/布尔宽容转字符串：YAML 里 `token: 12345` 会被解析成数字
+        let text;
+        if (typeof input === "string")
+            text = input;
+        else if (typeof input === "number" && def.allowNumber)
+            return input;
+        else if (typeof input === "number" || typeof input === "boolean")
+            text = String(input);
+        else
+            return this.#reject(issues, path, "应为字符串");
+        if (def.trim !== false)
+            text = text.trim();
+        if (def.min !== undefined && [...text].length < def.min) {
+            return this.#reject(issues, path, `长度不能少于 ${def.min}`);
+        }
+        if (def.max !== undefined && [...text].length > def.max) {
+            return this.#reject(issues, path, `长度不能超过 ${def.max}`);
+        }
+        if (def.pattern && !def.pattern.test(text)) {
+            return this.#reject(issues, path, `格式不正确（需匹配 ${def.pattern.source}）`);
+        }
+        return text;
+    }
+    /**
+     * 校验数值
+     * @param input 输入
+     * @param path 路径
+     * @param issues 问题容器
+     * @returns 数值或 INVALID
+     */
+    #validateNumber(input, path, issues) {
+        const def = this.#def;
+        let num;
+        if (typeof input === "number")
+            num = input;
+        else if (typeof input === "string" && input.trim() !== "" && Number.isFinite(Number(input))) {
+            num = Number(input);
+        }
+        else
+            return this.#reject(issues, path, "应为数字");
+        if (!Number.isFinite(num))
+            return this.#reject(issues, path, "应为有限数字");
+        if (def.int && !Number.isInteger(num))
+            return this.#reject(issues, path, "应为整数");
+        if (def.min !== undefined && num < def.min)
+            return this.#reject(issues, path, `不能小于 ${def.min}`);
+        if (def.max !== undefined && num > def.max)
+            return this.#reject(issues, path, `不能大于 ${def.max}`);
+        return num;
+    }
+    /**
+     * 校验布尔
+     * @param input 输入
+     * @param path 路径
+     * @param issues 问题容器
+     * @returns 布尔或 INVALID
+     */
+    #validateBoolean(input, path, issues) {
+        if (typeof input === "boolean")
+            return input;
+        if (typeof input === "string") {
+            const text = input.trim().toLowerCase();
+            if (["true", "1", "yes", "on", "是"].includes(text))
+                return true;
+            if (["false", "0", "no", "off", "否"].includes(text))
+                return false;
+        }
+        if (input === 1)
+            return true;
+        if (input === 0)
+            return false;
+        return this.#reject(issues, path, "应为布尔值");
+    }
+    /**
+     * 校验枚举
+     * @param input 输入
+     * @param path 路径
+     * @param issues 问题容器
+     * @returns 枚举值或 INVALID
+     */
+    #validateEnum(input, path, issues) {
+        const items = this.#def.enumItems ?? [];
+        for (const item of items) {
+            if (item.value === input)
+                return input;
+            // WebUI 的 select 只会回传字符串，数字枚举需要按文本比一次
+            if (String(item.value) === String(input))
+                return item.value;
+        }
+        const allowed = items.map(i => String(i.value)).join(" / ");
+        return this.#reject(issues, path, `只能是 ${allowed}`);
+    }
+    /**
+     * 校验数组
+     * @param input 输入
+     * @param path 路径
+     * @param issues 问题容器
+     * @returns 数组或 INVALID
+     */
+    #validateArray(input, path, issues) {
+        const def = this.#def;
+        let list;
+        if (Array.isArray(input))
+            list = input;
+        else if (def.wrapSingle)
+            list = [input];
+        else
+            return this.#reject(issues, path, "应为数组");
+        if (def.min !== undefined && list.length < def.min) {
+            return this.#reject(issues, path, `至少需要 ${def.min} 项`);
+        }
+        if (def.max !== undefined && list.length > def.max) {
+            return this.#reject(issues, path, `最多 ${def.max} 项`);
+        }
+        const element = def.element;
+        if (!element)
+            return deepClone(list);
+        const out = [];
+        let bad = false;
+        for (let i = 0; i < list.length; i++) {
+            const item = element.#validate(list[i], `${path}[${i}]`, issues);
+            if (item === INVALID)
+                bad = true;
+            else
+                out.push(item);
+        }
+        return bad ? INVALID : out;
+    }
+    /**
+     * 校验对象
+     * @param input 输入
+     * @param path 路径
+     * @param issues 问题容器
+     * @returns 对象或 INVALID
+     */
+    #validateObject(input, path, issues) {
+        const def = this.#def;
+        if (!isPlainObject(input))
+            return this.#reject(issues, path, "应为对象");
+        const shape = def.shape ?? {};
+        const out = {};
+        let bad = false;
+        for (const [key, child] of Object.entries(shape)) {
+            const childPath = path === "" ? key : `${path}.${key}`;
+            const value = child.#validate(input[key], childPath, issues);
+            if (value === INVALID)
+                bad = true;
+            else if (value !== undefined)
+                out[key] = value;
+        }
+        for (const key of Object.keys(input)) {
+            if (Object.prototype.hasOwnProperty.call(shape, key))
+                continue;
+            const childPath = path === "" ? key : `${path}.${key}`;
+            if (def.strict) {
+                this.#fail(issues, childPath, "无法识别的配置项");
+                bad = true;
+            }
+            else {
+                // 保留但提示：可能是拼写错误，也可能来自暂时卸载的插件
+                this.#fail(issues, childPath, "无法识别的配置项，已原样保留", "warn");
+                out[key] = deepClone(input[key]);
+            }
+        }
+        return bad ? INVALID : out;
+    }
+    /**
+     * 校验字典
+     * @param input 输入
+     * @param path 路径
+     * @param issues 问题容器
+     * @returns 字典或 INVALID
+     */
+    #validateRecord(input, path, issues) {
+        if (!isPlainObject(input))
+            return this.#reject(issues, path, "应为键值对象");
+        const valueSchema = this.#def.valueSchema;
+        if (!valueSchema)
+            return deepClone(input);
+        const out = {};
+        let bad = false;
+        for (const [key, raw] of Object.entries(input)) {
+            const childPath = path === "" ? key : `${path}.${key}`;
+            const value = valueSchema.#validate(raw, childPath, issues);
+            if (value === INVALID)
+                bad = true;
+            else
+                out[key] = value;
+        }
+        return bad ? INVALID : out;
+    }
+}
+_a = Schema;
+/**
+ * 创建基础节点
+ * @param def 定义片段
+ * @returns schema
+ */
+function make(def) {
+    return new Schema({ ...def, meta: def.meta ?? {} });
+}
+/**
+ * 字符串
+ * @returns 字符串 schema
+ */
+function string() {
+    return make({ kind: "string" });
+}
+/**
+ * 数字
+ * @returns 数字 schema
+ */
+function number() {
+    return make({ kind: "number" });
+}
+/**
+ * 布尔
+ * @returns 布尔 schema
+ */
+function boolean() {
+    return make({ kind: "boolean" });
+}
+/**
+ * 字面量
+ * @param value 唯一允许的值
+ * @returns 字面量 schema
+ */
+function literal(value) {
+    return make({ kind: "literal", literalValue: value });
+}
+/**
+ * 枚举
+ * @param values 候选值
+ * @param labels 值到展示文案的映射
+ * @returns 枚举 schema
+ */
+function enumOf(values, labels) {
+    const items = values.map(value => {
+        const label = labels?.[String(value)];
+        return label === undefined ? { value } : { value, label };
+    });
+    return make({ kind: "enum", enumItems: items, meta: { widget: "select" } });
+}
+/**
+ * 带说明的枚举（WebUI 下拉框里显示 label 与 description）
+ * @param items 候选项
+ * @returns 枚举 schema
+ */
+function select(items) {
+    return make({
+        kind: "enum",
+        enumItems: items.map(item => ({ ...item })),
+        meta: { widget: "select" }
+    });
+}
+/**
+ * 数组
+ * @param element 元素 schema
+ * @returns 数组 schema
+ */
+function array(element) {
+    return make({ kind: "array", element });
+}
+/**
+ * 对象
+ * @param shape 字段表
+ * @returns 对象 schema
+ */
+function object(shape) {
+    return make({ kind: "object", shape });
+}
+/**
+ * 字典（键任意、值同构）
+ * @param valueSchema 值 schema
+ * @returns 字典 schema
+ */
+function record(valueSchema) {
+    return make({ kind: "record", valueSchema, meta: { widget: "keyValue" } });
+}
+/**
+ * 任意值（不校验）
+ *
+ * 兼容出口：插件存在确实无法描述的结构时使用，但 WebUI 仅能提供 JSON 编辑框。
+ * @returns 任意值 schema
+ */
+function unknownValue() {
+    return make({ kind: "unknown", meta: { widget: "code" } });
+}
+/**
+ * 时长（`"30s"` / `"7d"` / 毫秒数）
+ *
+ * 数值写法与字符串写法都原样保留，不互相转换 —— 见 `SchemaDef.allowNumber`。
+ * @returns 时长 schema
+ */
+function duration() {
+    return make({ kind: "string", meta: { widget: "duration" }, allowNumber: true }).check("时长格式应为毫秒数或形如 30s / 5m / 1h / 7d", value => typeof value === "number" || parseDuration(value, Number.NaN) === parseDuration(value, 0));
+}
+/**
+ * cron 表达式
+ * @returns cron schema
+ */
+function cron() {
+    return make({ kind: "string", meta: { widget: "cron" } }).check("cron 表达式应为 5 或 6 段", value => {
+        const parts = value.trim().split(/\s+/);
+        return parts.length === 5 || parts.length === 6;
+    });
+}
+/**
+ * 端口号
+ * @returns 端口 schema
+ */
+function port() {
+    return make({ kind: "number", meta: { widget: "number" }, int: true, min: 1, max: 65535 });
+}
+/**
+ * 密码 / 令牌（自动脱敏）
+ * @returns 敏感字符串 schema
+ */
+function password() {
+    return string().secret();
+}
+/**
+ * 多行文本
+ * @returns 文本域 schema
+ */
+function text() {
+    return string().widget("textarea");
+}
+/**
+ * 字符串标签数组（WebUI 用 tag 输入框）
+ * @returns 标签数组 schema
+ */
+function tags() {
+    return array(string()).widget("tags").single();
+}
+/**
+ * id 列表（QQ 号 / 群号，允许写单个值）
+ * @returns id 数组 schema
+ */
+function ids() {
+    return array(string().pattern(/^\d{1,20}$/, "应为纯数字 id"))
+        .widget("tags")
+        .single();
+}
+/**
+ * 目录路径
+ * @returns 目录 schema
+ */
+function dir() {
+    return string().widget("dir");
+}
+/**
+ * 文件路径
+ * @returns 文件 schema
+ */
+function file() {
+    return string().widget("file");
+}
+/**
+ * schema 构造器集合
+ *
+ * 用法：
+ * ```ts
+ * const conf = s.object({
+ *   port: s.port().default(3000).title("监听端口"),
+ *   mode: s.enum(["ws", "ws-reverse"]).default("ws-reverse").title("连接方式")
+ * })
+ * type Conf = Infer<typeof conf>
+ * ```
+ */
+export const s = {
+    string,
+    number,
+    boolean,
+    literal,
+    enum: enumOf,
+    select,
+    array,
+    object,
+    record,
+    unknown: unknownValue,
+    duration,
+    cron,
+    port,
+    password,
+    text,
+    tags,
+    ids,
+    dir,
+    file
+};
+//# sourceMappingURL=schema.js.map