@lsby/net-core 0.11.2 → 0.13.3

package/dist/esm/interface/interface-logic.d.ts

@@ -1,8 +1,132 @@
-import '@lsby/ts-fp-data';
-import 'express';
-import '../help/interior.js';
-export { n as 任意接口逻辑, 兼 as 兼容空对象, 可 as 可调用接口逻辑, m as 接口逻辑, l as 接口逻辑Base, j as 接口逻辑正确类型, i as 接口逻辑错误类型, k as 接口逻辑附加参数类型, 清 as 清理函数类型, 空 as 空对象, s as 获得接口逻辑上游接口类型, o as 获得接口逻辑插件类型, t as 获得接口逻辑最后接口类型, r as 获得接口逻辑正确类型, q as 获得接口逻辑错误类型, p as 获得接口逻辑附加参数类型, 计 as 计算接口逻辑参数, v as 计算接口逻辑正确结果, u as 计算接口逻辑错误结果 } from '../interface-base-DDfmN_Dg.js';
-import 'zod';
+import { Either } from '@lsby/ts-fp-data';
+import { Request, Response } from 'express';
+import { 联合转元组 as _____ } from '../help/interior.js';
+import { 空对象 as ___, 请求附加参数类型 as ________$1 } from '../types/types.js';
+import { 任意插件 as ____, 合并插件正确结果 as ________ } from './interface-plugin.js';
 import '@lsby/ts-log';
-import 'node:http';
-import './interface-retuen.js';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+import 'zod';
+
+type 清理函数类型<插件类型 extends ____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型> = (参数: ________<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: ________$1) => Promise<void>;
+type 接口逻辑错误类型 = Record<string, any> | string | never;
+type 接口逻辑正确类型 = Record<string, any>;
+type 接口逻辑附加参数类型 = Record<string, any>;
+/**
+ * ### 接口逻辑
+ *
+ * 接口逻辑是接口的实际行为, 它由以下部分组成:
+ * - 插件: 业务逻辑的前置行为, 通过与req句柄交互, 获得接口需要的信息, 见 {@link 插件}
+ * - 业务逻辑: 实际的运行逻辑, 是一个函数
+ *   - 业务逻辑的参数是:
+ *     - 参数: 当前接口逻辑的插件提供的数据
+ *     - 逻辑附加参数: 上游接口逻辑提供的数据和能力
+ *     - 请求附加参数: 框架提供的信息, 例如请求id
+ *   - 业务逻辑应当返回 Either 值, 表示执行成功还是失败
+ *   - 业务逻辑应当尽可能是纯的, 便于单独测试和调用
+ *
+ * #### 两用性
+ *
+ * 接口逻辑可以被两种不同的方法使用:
+ * - 组成接口: 将其作为 {@link 接口} 的一部分.
+ *   此时, 插件会被执行, 插件将从HTTP上下文中获得信息, 提供给业务逻辑.
+ * - 内部调用: 使用 .实现 方法, 在其他代码中调用接口逻辑.
+ *   此时, 插件会被跳过, 不会从HTTP上下文中获取任何信息(因为根本就不存在HTTP上下文).
+ *   而本来由插件提供的信息将改为需要通过调用参数提供(是类型安全的).
+ * 这意味着大部分接口逻辑的实现是纯的, 并且可以独立被调用, 非常容易被测试
+ *
+ * #### 组合
+ *
+ * 允许将多个接口逻辑进行组合, 形成新的接口逻辑
+ * - 目前只提供"绑定"一种组合方式
+ * - 未来可能提供更多组合方法
+ *
+ * ##### 绑定
+ *
+ * 这种组合方式将接口逻辑看作一个类monad结构的Either
+ *
+ * 考虑这样的代码:
+ *
+ * ```typescript
+ * 接口逻辑.空逻辑()
+ *   .绑定(A)
+ *   .绑定(B) // B中可以调用A的返回结果
+ *   .绑定(C) // C中可以调用A和B的返回结果
+ * ```
+ *
+ * 这类似于:
+ *
+ * ```haskell
+ * do
+ *   a <- A
+ *   b <- B // B中可以调用a
+ *   c <- C // C中可以调用a和b
+ *   pure {a, b, c}
+ * ```
+ *
+ * 注意: 上面的A, B, C的结果皆为Either, 如果返回左值, 后续过程将直接被跳过
+ *
+ * ## 复用性和代数效应
+ *
+ * 推荐抽象通用组件, 并构造纯代数效应链:
+ *
+ * 考虑这样的代码:
+ *
+ * ```typescript
+ * 接口逻辑.空逻辑()
+ *   .绑定(用户鉴权)      // 通用, 可通过参数与业务解耦, 实现跨项目复用
+ *   .绑定(缓存)          // 通用, 可通过参数与业务解耦, 实现跨项目复用
+ *   .绑定(限流)          // 通用, 可通过参数与业务解耦, 实现跨项目复用
+ *   .绑定(业务相关逻辑)  // 业务相关逻辑, 但不触发副作用, 而是返回"描述副作用的数据"
+ *   .绑定(操作数据库)    // 业务相关逻辑, 解析"描述副作用的数据", 并实际执行
+ * ```
+ *
+ * 这样的好处是:
+ * - 跨项目复用的逻辑块
+ * - 业务逻辑可以保持是纯的, 非常方便独立测试
+ */
+declare abstract class 接口逻辑Base<插件类型 extends ____[], in 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 正确类型 extends 接口逻辑正确类型, 上游接口类型 extends 任意接口逻辑 | null = null, 最后接口类型 extends 任意接口逻辑 | null = null> {
+    private 上游接口;
+    private 最后接口;
+    static 空逻辑(): 接口逻辑Base<[], ___, never, {}, null, null>;
+    static 完整构造<插件类型 extends ____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型, 上游接口类型 extends 任意接口逻辑 | null, 最后接口类型 extends 任意接口逻辑 | null>(插件们: [...插件类型], 实现: (参数: ________<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: ________$1) => Promise<Either<错误类型, 返回类型>>, 清理函数: 清理函数类型<插件类型, 逻辑附加参数类型> | undefined, 上游接口逻辑: 上游接口类型, 最后接口逻辑: 最后接口类型): 接口逻辑Base<插件类型, 逻辑附加参数类型, 错误类型, 返回类型, 上游接口类型, 最后接口类型>;
+    static 构造<插件类型 extends ____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型>(插件们: [...插件类型], 实现: (参数: ________<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: ________$1) => Promise<Either<错误类型, 返回类型>>, 清理函数?: 清理函数类型<插件类型, 逻辑附加参数类型> | undefined): 接口逻辑Base<插件类型, 逻辑附加参数类型, 错误类型, 返回类型, null, null>;
+    protected readonly __类型保持符号_协变?: [插件类型, 错误类型, 正确类型];
+    protected readonly __类型保持符号_逆变?: (a: 逻辑附加参数类型) => void;
+    constructor(上游接口: 上游接口类型, 最后接口: 最后接口类型);
+    计算插件结果(req: Request, res: Response, 请求附加参数: ________$1): Promise<Either<{
+        code: number;
+        data: any;
+    }, ________<插件类型>>>;
+    abstract 获得插件们(): [...插件类型];
+    abstract 实现(参数: ________<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: ________$1): Promise<Either<错误类型, 正确类型>>;
+    获得清理函数?(): 清理函数类型<插件类型, 逻辑附加参数类型> | undefined;
+    调用(合并插件结果: ________<插件类型>, 传入的逻辑附加参数: 逻辑附加参数类型, 传入的请求附加参数: ________$1): Promise<Either<错误类型, 正确类型>>;
+    绑定<输入的插件类型 extends ____[], 输入的错误类型 extends 接口逻辑错误类型, 输入的返回类型 extends 接口逻辑正确类型, 输入的上游接口逻辑类型 extends 任意接口逻辑 | null, 输入的最后接口逻辑类型 extends 任意接口逻辑 | null>(输入: 接口逻辑Base<输入的插件类型, 正确类型, 输入的错误类型, 输入的返回类型, 输入的上游接口逻辑类型, 输入的最后接口逻辑类型>): 接口逻辑Base<[
+        ...插件类型,
+        ...输入的插件类型
+    ], 逻辑附加参数类型, 错误类型 | 输入的错误类型, 正确类型 & 输入的返回类型, typeof this, typeof 输入>;
+    获得上游接口(): 上游接口类型;
+    获得最后接口(): 最后接口类型;
+}
+/**
+ * 详情见 {@link 接口逻辑Base}
+ */
+declare abstract class 接口逻辑<插件类型 extends ____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 正确类型 extends 接口逻辑正确类型> extends 接口逻辑Base<插件类型, 逻辑附加参数类型, 错误类型, 正确类型, null, null> {
+    constructor();
+}
+type 任意接口逻辑 = 接口逻辑Base<any, any, any, any, any, any>;
+type 获得接口逻辑插件类型<A> = A extends 接口逻辑Base<infer X, any, any, any, any, any> ? X : never;
+type 获得接口逻辑附加参数类型<A> = A extends 接口逻辑Base<any, infer X, any, any, any, any> ? X : never;
+type 获得接口逻辑错误类型<A> = A extends 接口逻辑Base<any, any, infer X, any, any, any> ? X : never;
+type 获得接口逻辑正确类型<A> = A extends 接口逻辑Base<any, any, any, infer X, any, any> ? X : never;
+type 获得接口逻辑上游接口类型<A> = A extends 接口逻辑Base<any, any, any, any, infer X, any> ? X : never;
+type 获得接口逻辑最后接口类型<A> = A extends 接口逻辑Base<any, any, any, any, any, infer X> ? X : never;
+type 计算接口逻辑参数<接口逻辑> = ________<获得接口逻辑插件类型<接口逻辑>>;
+type 计算接口逻辑错误结果<接口逻辑> = _____<获得接口逻辑错误类型<接口逻辑>>;
+type 计算接口逻辑正确结果<接口逻辑> = {
+    [k in keyof 获得接口逻辑正确类型<接口逻辑>]: 获得接口逻辑正确类型<接口逻辑>[k];
+};
+
+export { type 任意接口逻辑, 接口逻辑, 接口逻辑Base, type 接口逻辑正确类型, type 接口逻辑错误类型, type 接口逻辑附加参数类型, type 清理函数类型, type 获得接口逻辑上游接口类型, type 获得接口逻辑插件类型, type 获得接口逻辑最后接口类型, type 获得接口逻辑正确类型, type 获得接口逻辑错误类型, type 获得接口逻辑附加参数类型, type 计算接口逻辑参数, type 计算接口逻辑正确结果, type 计算接口逻辑错误结果 };

package/dist/esm/interface/interface-logic.js

@@ -1,8 +1,12 @@
 import {
   接口逻辑,
   接口逻辑Base
-} from "../chunk-E23EZWBE.js";
-import "../chunk-7LQRWJ3X.js";
+} from "../chunk-TE6CG2FF.js";
+import "../chunk-MVMDWJTB.js";
+import "../chunk-P23ZAK4I.js";
+import "../chunk-MRTIZDKN.js";
+import "../chunk-NTDDPUP7.js";
+import "../chunk-F5IAX56T.js";
 export {
   \u63A5\u53E3\u903B\u8F91,
   \u63A5\u53E3\u903B\u8F91Base

package/dist/esm/interface/interface-plugin.d.ts

@@ -0,0 +1,37 @@
+import { Either } from '@lsby/ts-fp-data';
+import { Request, Response } from 'express';
+import { z } from 'zod';
+import { 请求附加参数类型 as ________ } from '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+
+/**
+ * ### 插件
+ *
+ * 插件是 {@link 接口逻辑} 的一部分, 是"业务逻辑"的前置逻辑
+ * - 可以获得原始的req, res对象, 但res对象仅仅是为了兼容express的某些插件添加的, 不要使用res返回数据
+ * - 插件的定位是, 从HTTP上下文中获得信息, 使后续逻辑能正确运行
+ *   - 插件提供的信息是必要的, 如果插件无法获取到信息, 意味着接口逻辑不能正常运行
+ *   - 插件提供错误处理能力, 可以在插件中返回左值来拒绝请求, 此时, 服务器会直接返回错误信息, 不会进入后续逻辑
+ */
+declare class 插件<错误结果 extends z.ZodObject<{
+    code: z.ZodLiteral<number>;
+    data: z.ZodTypeAny;
+}> | z.ZodNever, 正确结果 extends z.AnyZodObject> {
+    private 错误类型描述;
+    private 正确类型描述;
+    private 实现;
+    protected readonly __类型保持符号?: [错误结果, 正确结果];
+    constructor(错误类型描述: 错误结果, 正确类型描述: 正确结果, 实现: (req: Request, res: Response, 附加参数: ________) => Promise<Either<z.infer<错误结果>, z.infer<正确结果>>>);
+    获得错误类型描述(): 错误结果;
+    获得正确类型描述(): 正确结果;
+    运行(req: Request, res: Response, 附加参数: ________): Promise<Either<z.infer<错误结果>, z.infer<正确结果>>>;
+}
+type 任意插件 = 插件<any, any>;
+type 取插件错误ts类型<A> = A extends 插件<infer x, any> ? z.infer<x> : never;
+type 取插件正确ts类型<A> = A extends 插件<any, infer x> ? z.infer<x> : never;
+type 合并插件正确结果<Arr extends Array<任意插件>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<任意插件> ? 取插件正确ts类型<插件项> & 合并插件正确结果<xs> : {} : {} : {};
+
+export { type 任意插件, type 取插件正确ts类型, type 取插件错误ts类型, type 合并插件正确结果, 插件 };

package/dist/esm/{plugin/plug.js → interface/interface-plugin.js}

@@ -1,6 +1,6 @@
 import {
   插件
-} from "../chunk-43GZE5YL.js";
+} from "../chunk-EGIJQJFI.js";
 export {
   \u63D2\u4EF6
 };

package/dist/esm/interface/interface-returner.d.ts

@@ -0,0 +1,32 @@
+import { Either } from '@lsby/ts-fp-data';
+import { Request, Response } from 'express';
+import { z } from 'zod';
+import { 请求附加参数类型 as ________$2 } from '../types/types.js';
+import { 接口逻辑错误类型 as ________, 接口逻辑正确类型 as ________$1 } from './interface-logic.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+import '../help/interior.js';
+import './interface-plugin.js';
+
+/**
+ * ### 接口返回器
+ *
+ * 接口返回器是 {@link 接口} 的组成部分
+ *
+ * 描述如何将 {@link 接口逻辑} 返回的Either值返回给客户端
+ */
+declare abstract class 接口返回器<实现错误类型 extends ________, 实现正确类型 extends ________$1, 接口错误类型Zod extends z.ZodTypeAny, 接口正确类型Zod extends z.ZodTypeAny> {
+    protected readonly __类型保持符号?: [实现错误类型, 实现正确类型, 接口错误类型Zod, 接口正确类型Zod];
+    abstract 获得接口错误形式Zod(): 接口错误类型Zod;
+    abstract 获得接口正确形式Zod(): 接口正确类型Zod;
+    abstract 实现(req: Request, res: Response, 数据: Either<实现错误类型, 实现正确类型>, 请求附加参数: ________$2): void;
+}
+type 任意接口返回器 = 接口返回器<any, any, any, any>;
+type 获得接口返回器实现错误类型<A> = A extends 接口返回器<infer X, any, any, any> ? X : never;
+type 获得接口返回器实现正确类型<A> = A extends 接口返回器<any, infer X, any, any> ? X : never;
+type 获得接口返回器接口错误类型<A> = A extends 接口返回器<any, any, infer X, any> ? z.infer<X> : never;
+type 获得接口返回器接口正确类型<A> = A extends 接口返回器<any, any, any, infer X> ? z.infer<X> : never;
+
+export { type 任意接口返回器, 接口返回器, type 获得接口返回器实现正确类型, type 获得接口返回器实现错误类型, type 获得接口返回器接口正确类型, type 获得接口返回器接口错误类型 };

package/dist/esm/interface/interface-returner.js

@@ -0,0 +1,6 @@
+import {
+  接口返回器
+} from "../chunk-FP6Q65NN.js";
+export {
+  \u63A5\u53E3\u8FD4\u56DE\u5668
+};

package/dist/esm/interface/interface-test.d.ts

@@ -1,9 +1,32 @@
-declare class 接口测试 {
-    private 前置实现;
-    private 中置实现;
-    private 后置实现;
-    constructor(前置实现: () => Promise<void>, 中置实现: () => Promise<object>, 后置实现: (中置结果: object) => Promise<void>);
+import { 任意接口 as ____, 获得接口返回器类型 as _________ } from './interface-base.js';
+import { 获得接口返回器接口错误类型 as _____________, 获得接口返回器接口正确类型 as _____________$1 } from './interface-returner.js';
+import '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+import './interface-logic.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../help/interior.js';
+import './interface-plugin.js';
+import 'zod';
+
+declare class 接口测试<接口类型 extends ____, 预期结果类型 extends '成功' | '失败'> {
+    private 接口;
+    private 预期结果;
+    private 前置过程;
+    private 中置过程;
+    private 后置过程;
+    constructor(接口: 接口类型, 预期结果: 预期结果类型, 前置过程: () => Promise<void>, 中置过程: () => Promise<object>, 后置过程: (解析结果: 预期结果类型 extends '失败' ? _____________<_________<接口类型>> : _____________$1<_________<接口类型>>, 中置结果: object) => Promise<void>);
+    运行(): Promise<void>;
+}
+type 任意接口测试 = 接口测试<any, any>;
+declare class 接口逻辑测试 {
+    private 前置过程;
+    private 后置过程;
+    constructor(前置过程: () => Promise<void>, 后置过程: () => Promise<void>);
     运行(): Promise<void>;
 }
 
-export { 接口测试 };
+export { type 任意接口测试, 接口测试, 接口逻辑测试 };

package/dist/esm/interface/interface-test.js

@@ -1,6 +1,8 @@
 import {
-  接口测试
-} from "../chunk-N7TPWCQ5.js";
+  接口测试,
+  接口逻辑测试
+} from "../chunk-GGNRLQAM.js";
 export {
-  \u63A5\u53E3\u6D4B\u8BD5
+  \u63A5\u53E3\u6D4B\u8BD5,
+  \u63A5\u53E3\u903B\u8F91\u6D4B\u8BD5
 };

package/dist/esm/plugin/custom-data.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { 插件 as __ } from '../interface/interface-plugin.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+
+declare let 错误类型描述: z.ZodNever;
+declare class 自定义数据插件<Data extends z.AnyZodObject> extends __<typeof 错误类型描述, Data> {
+    constructor(t: Data, data: z.infer<Data>);
+}
+
+export { 自定义数据插件 };

package/dist/esm/plugin/{extend/custom-data.js → custom-data.js}

@@ -1,7 +1,7 @@
 import {
   自定义数据插件
-} from "../../chunk-VMCAX3QH.js";
-import "../../chunk-43GZE5YL.js";
+} from "../chunk-HINGVOU6.js";
+import "../chunk-EGIJQJFI.js";
 export {
   \u81EA\u5B9A\u4E49\u6570\u636E\u63D2\u4EF6
 };

package/dist/esm/plugin/custom.d.ts

@@ -0,0 +1,18 @@
+import { Either } from '@lsby/ts-fp-data';
+import { Request, Response } from 'express';
+import { z } from 'zod';
+import { 插件 as __ } from '../interface/interface-plugin.js';
+import { 请求附加参数类型 as ________ } from '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+
+declare class 自定义插件<错误类型描述 extends z.ZodObject<{
+    code: z.ZodLiteral<number>;
+    data: z.ZodTypeAny;
+}> | z.ZodNever, 正确类型描述 extends z.AnyZodObject> extends __<错误类型描述, 正确类型描述> {
+    constructor(错误类型描述: 错误类型描述, 正确类型描述: 正确类型描述, 实现: (req: Request, res: Response, 附加参数: ________) => Promise<Either<z.infer<错误类型描述>, z.infer<正确类型描述>>>);
+}
+
+export { 自定义插件 };

package/dist/esm/plugin/custom.js

@@ -0,0 +1,7 @@
+import {
+  自定义插件
+} from "../chunk-7OU27OBO.js";
+import "../chunk-EGIJQJFI.js";
+export {
+  \u81EA\u5B9A\u4E49\u63D2\u4EF6
+};

package/dist/esm/plugin/form.d.ts

@@ -0,0 +1,37 @@
+import multer from 'multer';
+import { z } from 'zod';
+import { 严格递归合并对象 as ________ } from '../help/help.js';
+import { 获得接口逻辑插件类型 as __________ } from '../interface/interface-logic.js';
+import { 插件 as __, 任意插件 as ____, 取插件正确ts类型 as _____ts__ } from '../interface/interface-plugin.js';
+import '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../help/interior.js';
+
+declare let 错误类型描述: z.ZodObject<{
+    code: z.ZodLiteral<400>;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: 400;
+    data: string;
+}, {
+    code: 400;
+    data: string;
+}>;
+declare class Form参数解析插件<Result extends z.AnyZodObject> extends __<typeof 错误类型描述, z.ZodObject<{
+    form: Result;
+}>> {
+    constructor(t: Result, opt: multer.Options);
+}
+type 任意Form参数解析插件 = Form参数解析插件<any>;
+type 任意Form参数解析插件项 = 任意Form参数解析插件;
+type 合并Form插件结果<Arr extends Array<____>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<____> ? 插件项 extends 任意Form参数解析插件项 ? ________<{
+    form: _____ts__<插件项>['form'];
+}, 合并Form插件结果<xs>> : 合并Form插件结果<xs> : {} : {} : {};
+type 计算接口逻辑Form参数<接口逻辑> = 合并Form插件结果<__________<接口逻辑>>;
+
+export { Form参数解析插件, type 任意Form参数解析插件, type 任意Form参数解析插件项, type 合并Form插件结果, type 计算接口逻辑Form参数 };

package/dist/esm/plugin/form.js

@@ -0,0 +1,42 @@
+import {
+  递归截断字符串
+} from "../chunk-2CGBESLT.js";
+import {
+  插件
+} from "../chunk-EGIJQJFI.js";
+
+// src/plugin/form.ts
+import { Left, Right } from "@lsby/ts-fp-data";
+import multer from "multer";
+import { format } from "util";
+import { z } from "zod";
+var \u9519\u8BEF\u7C7B\u578B\u63CF\u8FF0 = z.object({ code: z.literal(400), data: z.string() });
+var Form\u53C2\u6570\u89E3\u6790\u63D2\u4EF6 = class _Form\u53C2\u6570\u89E3\u6790\u63D2\u4EF6 extends \u63D2\u4EF6 {
+  constructor(t, opt) {
+    super(\u9519\u8BEF\u7C7B\u578B\u63CF\u8FF0, z.object({ form: t }), async (req, res, \u9644\u52A0\u53C2\u6570) => {
+      let log = \u9644\u52A0\u53C2\u6570.log.extend(_Form\u53C2\u6570\u89E3\u6790\u63D2\u4EF6.name);
+      let upload = multer(opt);
+      let multerMiddleware = upload.any();
+      await new Promise(
+        (pRes, rej) => multerMiddleware(req, res, (err) => {
+          if (err !== null) {
+            rej(err);
+          } else {
+            pRes(null);
+          }
+        })
+      );
+      await log.debug("\u51C6\u5907\u89E3\u6790 Form \u53C2\u6570\uFF1A%o", JSON.stringify(\u9012\u5F52\u622A\u65AD\u5B57\u7B26\u4E32(req.body)));
+      let parseResult = t.safeParse(req.body);
+      if (parseResult.success === false) {
+        await log.error("\u89E3\u6790 Form \u53C2\u6570\u5931\u8D25\uFF1A%o", JSON.stringify(parseResult.error));
+        return new Left({ code: 400, data: format("\u89E3\u6790 Form \u53C2\u6570\u5931\u8D25: %o", JSON.stringify(parseResult.error)) });
+      }
+      await log.debug("\u6210\u529F\u89E3\u6790 Form \u53C2\u6570");
+      return new Right({ form: parseResult.data });
+    });
+  }
+};
+export {
+  Form\u53C2\u6570\u89E3\u6790\u63D2\u4EF6
+};

package/dist/esm/plugin/json.d.ts

@@ -0,0 +1,36 @@
+import express from 'express';
+import { z } from 'zod';
+import { 严格递归合并对象 as ________ } from '../help/help.js';
+import { 获得接口逻辑插件类型 as __________ } from '../interface/interface-logic.js';
+import { 插件 as __, 任意插件 as ____, 取插件正确ts类型 as _____ts__ } from '../interface/interface-plugin.js';
+import '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+import '@lsby/ts-fp-data';
+import '../help/interior.js';
+
+declare let 错误类型描述: z.ZodObject<{
+    code: z.ZodLiteral<400>;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: 400;
+    data: string;
+}, {
+    code: 400;
+    data: string;
+}>;
+declare class JSON参数解析插件<Result extends z.AnyZodObject> extends __<typeof 错误类型描述, z.ZodObject<{
+    json: Result;
+}>> {
+    constructor(t: Result, opt: Parameters<typeof express.json>[0]);
+}
+type 任意JSON参数解析插件 = JSON参数解析插件<any>;
+type 任意JSON参数解析插件项 = 任意JSON参数解析插件;
+type 合并JSON插件结果<Arr extends Array<____>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<____> ? 插件项 extends 任意JSON参数解析插件项 ? ________<{
+    json: _____ts__<插件项>['json'];
+}, 合并JSON插件结果<xs>> : 合并JSON插件结果<xs> : {} : {} : {};
+type 计算接口逻辑JSON参数<接口逻辑> = 合并JSON插件结果<__________<接口逻辑>>;
+
+export { JSON参数解析插件, type 任意JSON参数解析插件, type 任意JSON参数解析插件项, type 合并JSON插件结果, type 计算接口逻辑JSON参数 };

package/dist/esm/plugin/json.js

@@ -0,0 +1,8 @@
+import {
+  JSON参数解析插件
+} from "../chunk-PAP3X3RJ.js";
+import "../chunk-2CGBESLT.js";
+import "../chunk-EGIJQJFI.js";
+export {
+  JSON\u53C2\u6570\u89E3\u6790\u63D2\u4EF6
+};

package/dist/esm/plugin/log-headers.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { 插件 as __ } from '../interface/interface-plugin.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+
+declare let 错误类型描述: z.ZodNever;
+declare let 正确类型描述: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+declare class 调试请求头插件 extends __<typeof 错误类型描述, typeof 正确类型描述> {
+    constructor();
+}
+
+export { 调试请求头插件 };

package/dist/esm/plugin/{extend/log-headers.js → log-headers.js}

@@ -1,7 +1,7 @@
 import {
   调试请求头插件
-} from "../../chunk-7MHKNSNT.js";
-import "../../chunk-43GZE5YL.js";
+} from "../chunk-RWSXMQQI.js";
+import "../chunk-EGIJQJFI.js";
 export {
   \u8C03\u8BD5\u8BF7\u6C42\u5934\u63D2\u4EF6
 };

package/dist/esm/plugin/parse-path.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { 插件 as __ } from '../interface/interface-plugin.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+
+declare let 错误类型描述: z.ZodNever;
+declare let 正确类型描述: z.ZodObject<{
+    path: z.ZodObject<{
+        rawPath: z.ZodString;
+        dir: z.ZodString;
+        file: z.ZodString;
+        ext: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        rawPath: string;
+        dir: string;
+        file: string;
+        ext: string;
+    }, {
+        rawPath: string;
+        dir: string;
+        file: string;
+        ext: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    path: {
+        rawPath: string;
+        dir: string;
+        file: string;
+        ext: string;
+    };
+}, {
+    path: {
+        rawPath: string;
+        dir: string;
+        file: string;
+        ext: string;
+    };
+}>;
+/**
+ * 路径解析插件 - 用于解析和分析 HTTP 请求的路径
+ *
+ * 功能说明：
+ * - 对请求路径进行 URL 解码
+ * - 解析路径的各个组成部分：目录、文件名、扩展名
+ *
+ * 返回数据结构：
+ * - rawPath: 解码后的完整路径
+ * - dir: 目录部分
+ * - file: 文件名（含扩展名）
+ * - ext: 文件扩展名（包括点号）
+ *
+ * 使用示例：
+ * 请求 URL: /api/users/profile.json?id=123
+ * 返回结果:
+ * {
+ *   path: {
+ *     rawPath: "/api/users/profile.json",
+ *     dir: "/api/users",
+ *     file: "profile.json",
+ *     ext: ".json"
+ *   }
+ * }
+ */
+declare class 路径解析插件 extends __<typeof 错误类型描述, typeof 正确类型描述> {
+    constructor();
+}
+
+export { 路径解析插件 };

package/dist/esm/plugin/parse-path.js

@@ -0,0 +1,8 @@
+import {
+  路径解析插件
+} from "../chunk-JLNRCPJD.js";
+import "../chunk-2CGBESLT.js";
+import "../chunk-EGIJQJFI.js";
+export {
+  \u8DEF\u5F84\u89E3\u6790\u63D2\u4EF6
+};

package/dist/esm/plugin/query.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { 严格递归合并对象 as ________ } from '../help/help.js';
+import { 获得接口逻辑插件类型 as __________ } from '../interface/interface-logic.js';
+import { 插件 as __, 任意插件 as ____, 取插件正确ts类型 as _____ts__ } from '../interface/interface-plugin.js';
+import '../types/types.js';
+import '@lsby/ts-log';
+import '../global/model/web-socket.js';
+import 'ws';
+import '../global/model/hub.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../help/interior.js';
+
+declare let 错误类型描述: z.ZodObject<{
+    code: z.ZodLiteral<400>;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: 400;
+    data: string;
+}, {
+    code: 400;
+    data: string;
+}>;
+declare class Query参数解析插件<Result extends z.AnyZodObject> extends __<typeof 错误类型描述, z.ZodObject<{
+    query: Result;
+}>> {
+    constructor(t: Result);
+}
+type 任意Query参数解析插件 = Query参数解析插件<any>;
+type 任意Query参数解析插件项 = 任意Query参数解析插件;
+type 合并Query插件结果<Arr extends Array<____>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<____> ? 插件项 extends 任意Query参数解析插件项 ? ________<{
+    query: _____ts__<插件项>['query'];
+}, 合并Query插件结果<xs>> : 合并Query插件结果<xs> : {} : {} : {};
+type 计算接口逻辑Query参数<接口逻辑> = 合并Query插件结果<__________<接口逻辑>>;
+
+export { Query参数解析插件, type 任意Query参数解析插件, type 任意Query参数解析插件项, type 合并Query插件结果, type 计算接口逻辑Query参数 };

package/dist/esm/plugin/query.js

@@ -0,0 +1,8 @@
+import {
+  Query参数解析插件
+} from "../chunk-RVEKW2PT.js";
+import "../chunk-2CGBESLT.js";
+import "../chunk-EGIJQJFI.js";
+export {
+  Query\u53C2\u6570\u89E3\u6790\u63D2\u4EF6
+};