@lsby/net-core 0.6.6 → 0.6.7-beta.10

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

@@ -1,61 +1,7 @@
-import { Either } from '@lsby/ts-fp-data';
-import { Request, Response } from 'express';
-import { 插件项类型 as _____, 合并插件结果 as ______, 插件附加参数 as ______$1 } from '../plugin/plug.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../help/help.js';
+export { l as 任意接口逻辑, 可 as 可调用接口逻辑, k as 接口逻辑, i as 接口逻辑正确类型, h as 接口逻辑错误类型, j as 接口逻辑附加参数类型, m as 获得接口逻辑插件类型, p as 获得接口逻辑正确类型, o as 获得接口逻辑错误类型, n as 获得接口逻辑附加参数类型, q as 计算接口逻辑正确结果, 计 as 计算接口逻辑错误结果 } from '../interface-base-D-Zxt7-a.js';
 import 'zod';
-
-type 计算混合单一组合<A, B> = A extends 接口逻辑<infer A插件类型, infer A附加参数, infer A错误, infer A返回> ? B extends 接口逻辑<infer B插件类型, infer B附加参数, infer B错误, infer B返回> ? 接口逻辑<[...A插件类型, ...B插件类型], A附加参数 & Omit<B附加参数, keyof A返回>, A错误 | B错误, A返回 & B返回> : never : never;
-type 计算混合组合数组<Arr> = Arr extends [infer x] ? x : Arr extends [infer x, infer y] ? 计算混合单一组合<x, y> : Arr extends [infer x, infer y, ...infer s] ? 计算混合组合数组<[计算混合单一组合<x, y>, ...s]> : never;
-type 接口逻辑错误类型 = string | never;
-type 接口逻辑正确类型 = Record<string, any>;
-type 接口逻辑附加参数类型 = Record<string, any>;
-/**
- * # 接口逻辑的基础抽象类
- *
- * - 该类表示一个接口的逻辑执行过程, 包括插件的运行, 结果的合并以及业务逻辑的实际执行.
- * - 插件提供预处理功能, 例如参数解析等, 它通过解析express的上下文, 获得结果并提供给实现.
- * - 实现函数负责业务逻辑的主要操作, 例如数据库查询等, 它接收插件的处理结果, 并返回计算结果(用Either表示).
- * - 运行时除了获得express上下文外, 还可以接收自定义参数, 称为`逻辑附加参数`.
- * - 每个接口逻辑实例可以通过一些方法与其他接口逻辑合并, 形成一个复杂的流程.
- *
- * ## 构造:
- *
- * - 可以通过继承该抽象类, 并实现抽象函数来使用.
- * - 也可以通过静态方法`构造`来直接进行构造.
- *
- * ## 组合
- *
- * 通过组合, 可以将简单的逻辑模块化, 并按需构建复杂的接口处理流程.
- *
- * ### 混合
- *
- * - 该类提供了`混合`方法, 用于将多个接口逻辑实例合成一个复合接口逻辑.
- *   - 组合的接口逻辑会按顺序依次被调用.
- *   - 如果某接口逻辑返回左值, 则整个结构将立即返回该左值.
- *   - 否则, 将右值内容注入上下文, 允许之后的接口逻辑通过`逻辑附加参数`访问它.
- *   - 最终将返回最后一个接口逻辑的运行结果.
- * - 这类似于monad的do结构, 在该结构中, 每个运行结果都会被注入到全局上下文并消除monad包装, 而语句可以使用上下文的值.
- *
- * ### 其他组合方法用到再写
- */
-declare abstract class 接口逻辑<插件类型 extends _____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型> {
-    static 混合<逻辑们 extends 任意接口逻辑[]>(逻辑们: [...逻辑们]): 计算混合组合数组<逻辑们>;
-    static 构造<插件类型 extends _____[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型>(插件们: [...插件类型], 实现: (参数: ______<插件类型>, 逻辑附加参数: 逻辑附加参数类型) => Promise<Either<错误类型, 返回类型>>, 逻辑附加参数?: Partial<逻辑附加参数类型> | undefined): 接口逻辑<插件类型, 逻辑附加参数类型, 错误类型, 返回类型>;
-    private 内部的逻辑附加参数;
-    protected readonly __类型保持符号?: [插件类型, 逻辑附加参数类型, 错误类型, 返回类型];
-    abstract 获得插件们(): [...插件类型];
-    abstract 实现(参数: ______<插件类型>, 逻辑附加参数: 逻辑附加参数类型): Promise<Either<错误类型, 返回类型>>;
-    设置逻辑附加参数<A extends Partial<逻辑附加参数类型>>(设置参数: A): 接口逻辑<插件类型, Omit<逻辑附加参数类型, keyof A>, 错误类型, 返回类型>;
-    运行(req: Request, res: Response, 传入的逻辑附加参数: 逻辑附加参数类型, 传入的插件附加参数: ______$1): Promise<Either<错误类型, 返回类型>>;
-    混合<输入的插件类型 extends _____[], 输入的错误类型 extends 接口逻辑错误类型, 输入的返回类型 extends 接口逻辑正确类型>(输入: 接口逻辑<输入的插件类型, 返回类型, 输入的错误类型, 输入的返回类型>): 接口逻辑<[
-        ...插件类型,
-        ...输入的插件类型
-    ], 逻辑附加参数类型, 错误类型 | 输入的错误类型, 返回类型 & 输入的返回类型>;
-}
-type 任意接口逻辑 = 接口逻辑<any, any, any, any>;
-type 可调用接口逻辑 = 接口逻辑<any, Record<string, never>, 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> ? X : never;
-type 获得接口逻辑正确类型<A> = A extends 接口逻辑<any, any, any, infer X> ? X : never;
-
-export { type 任意接口逻辑, type 可调用接口逻辑, 接口逻辑, type 接口逻辑正确类型, type 接口逻辑错误类型, type 接口逻辑附加参数类型, type 获得接口逻辑插件类型, type 获得接口逻辑正确类型, type 获得接口逻辑错误类型, type 获得接口逻辑附加参数类型 };
+import '@lsby/ts-log';
+import 'node:http';

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

@@ -1,7 +1,6 @@
 import {
   接口逻辑
-} from "../chunk-2E2KK6JA.js";
-import "../chunk-3FDT2MPR.js";
+} from "../chunk-JQAGEE3X.js";
 export {
   \u63A5\u53E3\u903B\u8F91
 };

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

@@ -1,40 +1,7 @@
-import { Either } from '@lsby/ts-fp-data';
-import { 接口逻辑错误类型 as ________, 接口逻辑正确类型 as ________$1 } from './interface-logic.js';
-import 'express';
-import '../plugin/plug.js';
+import '@lsby/ts-fp-data';
+export { s as 任意接口结果转换器, t as 常用延时直接形式转换器, 常 as 常用形式转换器, r as 接口结果转换器 } from '../interface-base-D-Zxt7-a.js';
 import 'zod';
-
-/**
- * 描述接口逻辑返回的数据将以何种形式返回给前端.
- */
-declare abstract class 接口结果转换器<实现错误类型 extends ________, 实现正确类型 extends ________$1, 接口错误形式, 接口正确形式> {
-    protected readonly __类型保持符号?: [实现错误类型, 实现正确类型, 接口错误形式, 接口正确形式];
-    abstract 实现(数据: Either<实现错误类型, 实现正确类型>): 接口错误形式 | 接口正确形式;
-}
-type 任意接口结果转换器 = 接口结果转换器<any, any, any, any>;
-declare class 常用形式转换器<实现错误类型 extends ________, 实现正确类型 extends ________$1> extends 接口结果转换器<实现错误类型, 实现正确类型, {
-    status: 'fail';
-    data: 实现错误类型;
-}, {
-    status: 'success';
-    data: 实现正确类型;
-}> {
-    实现(数据: Either<实现错误类型, 实现正确类型>): {
-        status: 'fail';
-        data: 实现错误类型;
-    } | {
-        status: 'success';
-        data: 实现正确类型;
-    };
-}
-declare class 延时直接形式转换器<T, 实现错误类型 extends ________, 实现正确类型 extends Record<'fn', () => T>> extends 接口结果转换器<实现错误类型, 实现正确类型, {
-    status: 'fail';
-    data: 实现错误类型;
-}, T> {
-    实现(数据: Either<实现错误类型, 实现正确类型>): {
-        status: 'fail';
-        data: 实现错误类型;
-    } | T;
-}
-
-export { type 任意接口结果转换器, 常用形式转换器, 延时直接形式转换器, 接口结果转换器 };
+import 'express';
+import '../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';

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

@@ -1,10 +1,10 @@
 import {
+  常用延时直接形式转换器,
   常用形式转换器,
-  延时直接形式转换器,
   接口结果转换器
-} from "../chunk-JHQKJ7DH.js";
+} from "../chunk-6I3OJQWA.js";
 export {
+  \u5E38\u7528\u5EF6\u65F6\u76F4\u63A5\u5F62\u5F0F\u8F6C\u6362\u5668,
   \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668,
-  \u5EF6\u65F6\u76F4\u63A5\u5F62\u5F0F\u8F6C\u6362\u5668,
   \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668
 };

package/dist/esm/interface-base-D-Zxt7-a.d.ts

@@ -0,0 +1,176 @@
+import { z } from 'zod';
+import { Task, Either } from '@lsby/ts-fp-data';
+import { Request, Response } from 'express';
+import { 联合转元组 as _____ } from './help/help.js';
+import { Log } from '@lsby/ts-log';
+import * as http from 'node:http';
+
+type 请求附加参数类型 = {
+    log: Log;
+};
+declare class 服务器 {
+    private 接口们;
+    private 端口;
+    private 静态资源路径?;
+    private 默认get文件路径?;
+    private log;
+    constructor(接口们: 任意接口[], 端口: number, 静态资源路径?: string | undefined, 默认get文件路径?: string | undefined);
+    run(): Promise<{
+        ip: string[];
+        api: string[];
+        server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    }>;
+    private 处理请求;
+    private 处理静态资源;
+    private 处理接口逻辑;
+    private 初始化WebSocket;
+    private 关闭WebSocket连接;
+    private 获取本地地址;
+}
+
+/**
+ * 类似express中的中间件, 做一些前置过程, 例如解析参数, 解析文件等.
+ *
+ * 可以被注入在"接口逻辑"中, 为其提供前置数据.
+ */
+declare class 插件<Obj extends z.AnyZodObject> {
+    private 类型;
+    private 实现;
+    protected readonly __类型保持符号?: Obj;
+    constructor(类型: Obj, 实现: (req: Request, res: Response, 附加参数: 请求附加参数类型) => Promise<z.infer<Obj>>);
+    获得类型(): Obj;
+    运行(req: Request, res: Response, 附加参数: 请求附加参数类型): Promise<z.infer<Obj>>;
+}
+type 任意插件 = 插件<any>;
+type 包装插件项<A> = Task<A>;
+type 插件项类型 = 包装插件项<插件<z.AnyZodObject>>;
+type 取Task插件内部类型<A> = A extends Task<插件<infer x>> ? x : never;
+type 取Task插件类型<A> = A extends Task<infer x> ? x : never;
+type 取插件内部ts类型<A> = A extends 插件<infer x> ? z.infer<x> : never;
+type 合并插件结果<Arr extends Array<插件项类型>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<插件项类型> ? z.infer<取Task插件内部类型<插件项>> & 合并插件结果<xs> : {} : {} : {};
+
+type 接口逻辑错误类型 = string | never;
+type 接口逻辑正确类型 = Record<string, any>;
+type 接口逻辑附加参数类型 = Record<string, any>;
+/**
+ * # 接口逻辑的基础抽象类
+ *
+ * - 该类表示一个接口的逻辑执行过程, 包括插件的运行, 结果的合并以及业务逻辑的实际执行.
+ * - 插件提供预处理功能, 例如参数解析等, 它通过解析express的上下文, 获得结果并提供给实现.
+ * - 实现函数负责业务逻辑的主要操作, 例如数据库查询等, 它接收插件的处理结果, 并返回计算结果(用Either表示).
+ * - 运行时除了获得express上下文外, 还可以接收自定义参数, 称为`逻辑附加参数`.
+ * - 每个接口逻辑实例可以通过一些方法与其他接口逻辑合并, 形成一个复杂的流程.
+ *
+ * ## 构造:
+ *
+ * - 可以通过继承该抽象类, 并实现抽象函数来使用.
+ * - 也可以通过静态方法`构造`来直接进行构造.
+ *
+ * ## 组合
+ *
+ * 通过组合, 可以将简单的逻辑模块化, 并按需构建复杂的接口处理流程.
+ *
+ * ### 混合
+ *
+ * - 该类提供了`混合`方法, 用于将多个接口逻辑实例合成一个复合接口逻辑.
+ *   - 组合的接口逻辑会按顺序依次被调用.
+ *   - 如果某接口逻辑返回左值, 则整个结构将立即返回该左值.
+ *   - 否则, 将右值内容注入上下文, 允许之后的接口逻辑通过`逻辑附加参数`访问它.
+ *   - 最终将返回所有接口的结果的与.
+ * - 这类似于monad的do结构, 在该结构中, 每个运行结果都会被注入到全局上下文并消除monad包装, 而语句可以使用上下文的值.
+ *
+ * ### 其他组合方法用到再写
+ */
+declare abstract class 接口逻辑<插件类型 extends 插件项类型[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型> {
+    static 空逻辑(): 接口逻辑<[], {}, never, {}>;
+    static 构造<插件类型 extends 插件项类型[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型>(插件们: [...插件类型], 实现: (参数: 合并插件结果<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: 请求附加参数类型) => Promise<Either<错误类型, 返回类型>>): 接口逻辑<插件类型, 逻辑附加参数类型, 错误类型, 返回类型>;
+    protected readonly __类型保持符号?: [插件类型, 逻辑附加参数类型, 错误类型, 返回类型];
+    abstract 获得插件们(): [...插件类型];
+    abstract 实现(参数: 合并插件结果<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: 请求附加参数类型): Promise<Either<错误类型, 返回类型>>;
+    运行(req: Request, res: Response, 传入的逻辑附加参数: 逻辑附加参数类型, 传入的插件附加参数: 请求附加参数类型): Promise<Either<错误类型, 返回类型>>;
+    混合<输入的插件类型 extends 插件项类型[], 输入的错误类型 extends 接口逻辑错误类型, 输入的返回类型 extends 接口逻辑正确类型>(输入: 接口逻辑<输入的插件类型, 返回类型, 输入的错误类型, 输入的返回类型>): 接口逻辑<[
+        ...插件类型,
+        ...输入的插件类型
+    ], 逻辑附加参数类型, 错误类型 | 输入的错误类型, 返回类型 & 输入的返回类型>;
+}
+type 任意接口逻辑 = 接口逻辑<any, any, any, any>;
+type 可调用接口逻辑 = 接口逻辑<any, Record<string, never>, 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> ? X : never;
+type 获得接口逻辑正确类型<A> = A extends 接口逻辑<any, any, any, infer X> ? X : never;
+type 计算接口逻辑错误结果<接口逻辑> = _____<获得接口逻辑错误类型<接口逻辑>>;
+type 计算接口逻辑正确结果<接口逻辑> = {
+    [k in keyof 获得接口逻辑正确类型<接口逻辑>]: 获得接口逻辑正确类型<接口逻辑>[k];
+};
+
+/**
+ * 描述接口逻辑返回的数据将以何种形式返回给前端.
+ */
+declare abstract class 接口结果转换器<实现错误类型 extends 接口逻辑错误类型, 实现正确类型 extends 接口逻辑正确类型, 接口错误形式, 接口正确形式> {
+    protected readonly __类型保持符号?: [实现错误类型, 实现正确类型, 接口错误形式, 接口正确形式];
+    abstract 实现(数据: Either<实现错误类型, 实现正确类型>): 接口错误形式 | 接口正确形式;
+}
+type 任意接口结果转换器 = 接口结果转换器<any, any, any, any>;
+declare class 常用形式转换器<实现错误类型 extends 接口逻辑错误类型, 实现正确类型 extends 接口逻辑正确类型> extends 接口结果转换器<实现错误类型, 实现正确类型, {
+    status: 'fail';
+    data: 实现错误类型;
+}, {
+    status: 'success';
+    data: 实现正确类型;
+}> {
+    实现(数据: Either<实现错误类型, 实现正确类型>): {
+        status: 'fail';
+        data: 实现错误类型;
+    } | {
+        status: 'success';
+        data: 实现正确类型;
+    };
+}
+declare class 常用延时直接形式转换器<实现最终返回类型, 实现错误类型 extends 接口逻辑错误类型, 实现正确类型 extends () => 实现最终返回类型> extends 接口结果转换器<实现错误类型, 实现正确类型, {
+    status: 'fail';
+    data: 实现错误类型;
+}, 实现最终返回类型> {
+    实现(数据: Either<实现错误类型, 实现正确类型>): {
+        status: 'fail';
+        data: 实现错误类型;
+    } | 实现最终返回类型;
+}
+
+type 接口路径类型 = string;
+type 接口方法类型 = 'get' | 'post';
+/**
+ * 接口的描述.
+ */
+declare class 接口<路径类型 extends 接口路径类型, 方法类型 extends 接口方法类型, 逻辑类型 extends 可调用接口逻辑, 接口错误形式Zod extends z.ZodTypeAny, 接口正确形式Zod extends z.ZodTypeAny, 接口结果转换器类型 extends 接口结果转换器<获得接口逻辑错误类型<逻辑类型>, 获得接口逻辑正确类型<逻辑类型>, z.infer<接口错误形式Zod>, z.infer<接口正确形式Zod>>> {
+    private 请求路径;
+    private 请求方法;
+    private 接口逻辑;
+    private 接口错误形式Zod;
+    private 接口正确形式Zod;
+    private 结果转换器;
+    protected readonly __类型保持符号?: [
+        路径类型,
+        方法类型,
+        逻辑类型,
+        接口错误形式Zod,
+        接口正确形式Zod,
+        接口结果转换器类型
+    ];
+    constructor(请求路径: 路径类型, 请求方法: 方法类型, 接口逻辑: 逻辑类型, 接口错误形式Zod: 接口错误形式Zod, 接口正确形式Zod: 接口正确形式Zod, 结果转换器: 接口结果转换器类型);
+    获得路径(): 路径类型;
+    获得方法(): 方法类型;
+    获得逻辑(): 逻辑类型;
+    获得接口错误形式Zod(): 接口错误形式Zod;
+    获得接口正确形式Zod(): 接口正确形式Zod;
+    获得结果转换器(): 接口结果转换器类型;
+}
+type 任意接口 = 接口<any, any, any, any, any, any>;
+type 获得接口路径类型<A> = A extends 接口<infer X, any, any, any, any, any> ? X : never;
+type 获得接口方法类型<A> = A extends 接口<any, infer X, any, any, any, any> ? X : never;
+type 获得接口逻辑类型<A> = A extends 接口<any, any, infer X, any, any, any> ? X : never;
+type 获得接口错误形式<A> = A extends 接口<any, any, any, infer X, any, any> ? z.infer<X> : never;
+type 获得接口正确形式<A> = A extends 接口<any, any, any, any, infer X, any> ? z.infer<X> : never;
+type 获得接口结果转换器类型<A> = A extends 接口<any, any, any, any, any, infer X> ? X : never;
+
+export { type 接口方法类型 as a, 接口 as b, type 获得接口方法类型 as c, type 获得接口逻辑类型 as d, type 获得接口错误形式 as e, type 获得接口正确形式 as f, type 获得接口结果转换器类型 as g, type 接口逻辑错误类型 as h, type 接口逻辑正确类型 as i, type 接口逻辑附加参数类型 as j, 接口逻辑 as k, type 任意接口逻辑 as l, type 获得接口逻辑插件类型 as m, type 获得接口逻辑附加参数类型 as n, type 获得接口逻辑错误类型 as o, type 获得接口逻辑正确类型 as p, type 计算接口逻辑正确结果 as q, 接口结果转换器 as r, type 任意接口结果转换器 as s, 常用延时直接形式转换器 as t, type 任意插件 as u, type 插件项类型 as v, type 取Task插件类型 as w, type 取插件内部ts类型 as x, type 任意接口 as 任, type 包装插件项 as 包, type 取Task插件内部类型 as 取, type 可调用接口逻辑 as 可, type 合并插件结果 as 合, 常用形式转换器 as 常, type 接口路径类型 as 接, 插件 as 插, 服务器 as 服, type 获得接口路径类型 as 获, type 计算接口逻辑错误结果 as 计, type 请求附加参数类型 as 请 };

package/dist/esm/plugin/extend/chinese-path.d.ts

@@ -1,7 +1,10 @@
 import { z } from 'zod';
-import { 插件 as __ } from '../plug.js';
+import { 插 as __ } from '../../interface-base-D-Zxt7-a.js';
 import '@lsby/ts-fp-data';
 import 'express';
+import '../../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
 
 declare let zod类型表示: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 declare class 中文路径支持插件 extends __<typeof zod类型表示> {

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

@@ -1,7 +1,10 @@
 import { z } from 'zod';
-import { 插件 as __ } from '../plug.js';
+import { 插 as __ } from '../../interface-base-D-Zxt7-a.js';
 import '@lsby/ts-fp-data';
 import 'express';
+import '../../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
 
 declare class 自定义数据插件<Data extends z.AnyZodObject> extends __<Data> {
     private log;

package/dist/esm/plugin/extend/custom-data.js

@@ -1,8 +1,8 @@
 import {
   自定义数据插件
-} from "../../chunk-KCQRJ4JL.js";
+} from "../../chunk-47MYYUQZ.js";
 import "../../chunk-43GZE5YL.js";
-import "../../chunk-3FDT2MPR.js";
+import "../../chunk-LDWZKZLU.js";
 export {
   \u81EA\u5B9A\u4E49\u6570\u636E\u63D2\u4EF6
 };

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

@@ -1,7 +1,10 @@
 import express from 'express';
 import { AnyZodObject, z } from 'zod';
-import { 插件 as __, 包装插件项 as _____, 插件项类型 as _____$1, 取Task插件内部类型 as _Task______ } from '../plug.js';
+import { 插 as __, 包 as _____, v as _____$1, 取 as _Task______, m as __________ } from '../../interface-base-D-Zxt7-a.js';
 import '@lsby/ts-fp-data';
+import '../../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
 
 declare class JSON解析插件<Result extends AnyZodObject> extends __<Result> {
     private log;
@@ -10,5 +13,6 @@ declare class JSON解析插件<Result extends AnyZodObject> extends __<Result> {
 type 任意JSON解析插件 = JSON解析插件<any>;
 type 任意JSON解析插件项 = _____<任意JSON解析插件>;
 type 合并JSON插件结果<Arr extends Array<_____$1>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<_____$1> ? 插件项 extends 任意JSON解析插件项 ? z.infer<_Task______<插件项>> & 合并JSON插件结果<xs> : 合并JSON插件结果<xs> : {} : {} : {};
+type 计算接口逻辑JSON参数<接口逻辑> = 合并JSON插件结果<__________<接口逻辑>>;
 
-export { JSON解析插件, type 任意JSON解析插件, type 任意JSON解析插件项, type 合并JSON插件结果 };
+export { JSON解析插件, type 任意JSON解析插件, type 任意JSON解析插件项, type 合并JSON插件结果, type 计算接口逻辑JSON参数 };

package/dist/esm/plugin/extend/json.js

@@ -1,9 +1,9 @@
 import {
   JSON解析插件
-} from "../../chunk-DXXX45UR.js";
+} from "../../chunk-GKEZ4UTO.js";
 import "../../chunk-43GZE5YL.js";
-import "../../chunk-IGHJCQ2S.js";
-import "../../chunk-3FDT2MPR.js";
+import "../../chunk-RYGSLVLS.js";
+import "../../chunk-LDWZKZLU.js";
 export {
   JSON\u89E3\u6790\u63D2\u4EF6
 };

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

@@ -1,7 +1,10 @@
 import { z } from 'zod';
-import { 插件 as __ } from '../plug.js';
+import { 插 as __ } from '../../interface-base-D-Zxt7-a.js';
 import '@lsby/ts-fp-data';
 import 'express';
+import '../../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
 
 declare let zod类型表示: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 declare class 调试请求头插件 extends __<typeof zod类型表示> {

package/dist/esm/plugin/extend/log-headers.js

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

package/dist/esm/plugin/extend/send-file-plugin.d.ts

@@ -1,7 +1,10 @@
 import { z } from 'zod';
-import { 插件 as __ } from '../plug.js';
+import { 插 as __ } from '../../interface-base-D-Zxt7-a.js';
 import '@lsby/ts-fp-data';
 import 'express';
+import '../../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
 
 declare let zod类型表示: z.ZodObject<{
     sendFile: z.ZodFunction<z.ZodTuple<[z.ZodType<Buffer, z.ZodTypeDef, Buffer>], null>, z.ZodType<Buffer, z.ZodTypeDef, Buffer>>;

package/dist/esm/plugin/extend/urlencoded.d.ts

@@ -1,7 +1,10 @@
 import express from 'express';
 import { z } from 'zod';
-import { 插件 as __ } from '../plug.js';
+import { 插 as __ } from '../../interface-base-D-Zxt7-a.js';
 import '@lsby/ts-fp-data';
+import '../../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
 
 declare class 表单解析插件<Result extends z.AnyZodObject> extends __<Result> {
     private log;

package/dist/esm/plugin/extend/urlencoded.js

@@ -1,8 +1,8 @@
 import {
   表单解析插件
-} from "../../chunk-L36NOE2J.js";
+} from "../../chunk-JB4HVEXB.js";
 import "../../chunk-43GZE5YL.js";
-import "../../chunk-3FDT2MPR.js";
+import "../../chunk-LDWZKZLU.js";
 export {
   \u8868\u5355\u89E3\u6790\u63D2\u4EF6
 };

package/dist/esm/plugin/extend/web-socket.d.ts

@@ -1,7 +1,10 @@
 import { z } from 'zod';
-import { 插件 as __, 包装插件项 as _____, 插件项类型 as _____$1, 取Task插件类型 as _Task____ } from '../plug.js';
+import { 插 as __, 包 as _____, v as _____$1, w as _Task____ } from '../../interface-base-D-Zxt7-a.js';
 import '@lsby/ts-fp-data';
 import 'express';
+import '../../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
 
 declare class WebSocket插件<信息 extends z.AnyZodObject | z.ZodUnion<any>> extends __<z.ZodObject<{
     ws操作: z.ZodUnion<[

package/dist/esm/plugin/extend/web-socket.js

@@ -1,8 +1,8 @@
 import {
   WebSocket插件
-} from "../../chunk-Z3PYJGMZ.js";
+} from "../../chunk-XPC3O5HH.js";
 import "../../chunk-43GZE5YL.js";
-import "../../chunk-3FDT2MPR.js";
+import "../../chunk-LDWZKZLU.js";
 export {
   WebSocket\u63D2\u4EF6
 };

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

@@ -1,29 +1,7 @@
-import { Task } from '@lsby/ts-fp-data';
-import { Request, Response } from 'express';
-import { z } from 'zod';
-
-type 插件附加参数 = {
-    请求id: string;
-};
-/**
- * 类似express中的中间件, 做一些前置过程, 例如解析参数, 解析文件等.
- *
- * 可以被注入在"接口逻辑"中, 为其提供前置数据.
- */
-declare class 插件<Obj extends z.AnyZodObject> {
-    private 类型;
-    private 实现;
-    protected readonly __类型保持符号?: Obj;
-    constructor(类型: Obj, 实现: (req: Request, res: Response, 附加参数: 插件附加参数) => Promise<z.infer<Obj>>);
-    获得类型(): Obj;
-    运行(req: Request, res: Response, 附加参数: 插件附加参数): Promise<z.infer<Obj>>;
-}
-type 任意插件 = 插件<any>;
-type 包装插件项<A> = Task<A>;
-type 插件项类型 = 包装插件项<插件<z.AnyZodObject>>;
-type 取Task插件内部类型<A> = A extends Task<插件<infer x>> ? x : never;
-type 取Task插件类型<A> = A extends Task<infer x> ? x : never;
-type 取插件内部ts类型<A> = A extends 插件<infer x> ? z.infer<x> : never;
-type 合并插件结果<Arr extends Array<插件项类型>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<插件项类型> ? z.infer<取Task插件内部类型<插件项>> & 合并插件结果<xs> : {} : {} : {};
-
-export { type 任意插件, type 包装插件项, type 取Task插件内部类型, type 取Task插件类型, type 取插件内部ts类型, type 合并插件结果, 插件, type 插件附加参数, type 插件项类型 };
+import '@lsby/ts-fp-data';
+import 'express';
+import 'zod';
+export { u as 任意插件, 包 as 包装插件项, 取 as 取Task插件内部类型, w as 取Task插件类型, x as 取插件内部ts类型, 合 as 合并插件结果, 插 as 插件, v as 插件项类型 } from '../interface-base-D-Zxt7-a.js';
+import '../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';

package/dist/esm/server/server.d.ts

@@ -1,30 +1,7 @@
-import * as http from 'node:http';
-import { 任意接口 as ____ } from '../interface/interface-base.js';
+import '@lsby/ts-log';
+import 'node:http';
+export { 服 as 服务器, 请 as 请求附加参数类型 } from '../interface-base-D-Zxt7-a.js';
 import 'zod';
-import '../interface/interface-logic.js';
 import '@lsby/ts-fp-data';
 import 'express';
-import '../plugin/plug.js';
-import '../interface/interface-result.js';
-
-declare class 服务器 {
-    private 接口们;
-    private 端口;
-    private 静态资源路径?;
-    private 默认get文件路径?;
-    private log;
-    constructor(接口们: ____[], 端口: number, 静态资源路径?: string | undefined, 默认get文件路径?: string | undefined);
-    run(): Promise<{
-        ip: string[];
-        api: string[];
-        server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    }>;
-    private 处理请求;
-    private 处理静态资源;
-    private 处理接口逻辑;
-    private 初始化WebSocket;
-    private 关闭WebSocket连接;
-    private 获取本地地址;
-}
-
-export { 服务器 };
+import '../help/help.js';

package/dist/esm/server/server.js

@@ -1,8 +1,8 @@
 import {
   服务器
-} from "../chunk-TU5RBGGM.js";
-import "../chunk-IGHJCQ2S.js";
-import "../chunk-3FDT2MPR.js";
+} from "../chunk-3QNWAAXS.js";
+import "../chunk-RYGSLVLS.js";
+import "../chunk-LDWZKZLU.js";
 export {
   \u670D\u52A1\u5668
 };

package/dist/esm/wrapper/common-wrapper.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { 接 as ______, a as ______$1, k as ____, b as __, 常 as _______, o as __________, p as __________$1 } from '../interface-base-D-Zxt7-a.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
+
+declare class 常用形式接口封装<路径类型 extends ______, 方法类型 extends ______$1, 逻辑类型 extends ____<any, Record<string, never>, z.infer<接口错误形式Zod>, z.infer<接口正确形式Zod>>, 接口错误形式Zod extends z.ZodTypeAny, 接口正确形式Zod extends z.ZodTypeAny> extends __<路径类型, 方法类型, 逻辑类型, z.ZodObject<{
+    status: z.ZodLiteral<'fail'>;
+    data: 接口错误形式Zod;
+}>, z.ZodObject<{
+    status: z.ZodLiteral<'success'>;
+    data: 接口正确形式Zod;
+}>, _______<__________<逻辑类型>, __________$1<逻辑类型>>> {
+    constructor(请求路径: 路径类型, 请求方法: 方法类型, 接口逻辑: 逻辑类型, 逻辑错误类型Zod: 接口错误形式Zod, 逻辑正确类型Zod: 接口正确形式Zod);
+}
+
+export { 常用形式接口封装 };

package/dist/esm/wrapper/common-wrapper.js

@@ -0,0 +1,8 @@
+import {
+  常用形式接口封装
+} from "../chunk-BEFZ7IFH.js";
+import "../chunk-JMR7QAHO.js";
+import "../chunk-6I3OJQWA.js";
+export {
+  \u5E38\u7528\u5F62\u5F0F\u63A5\u53E3\u5C01\u88C5
+};

package/dist/esm/wrapper/deferred-result-wrapper.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { 接 as ______, a as ______$1, k as ____, b as __, t as ___________, o as __________, p as __________$1 } from '../interface-base-D-Zxt7-a.js';
+import '@lsby/ts-fp-data';
+import 'express';
+import '../help/help.js';
+import '@lsby/ts-log';
+import 'node:http';
+
+declare class 常用延时直接形式接口封装<路径类型 extends ______, 方法类型 extends ______$1, 逻辑类型 extends ____<any, Record<string, never>, z.infer<接口错误形式Zod>, () => z.infer<接口正确形式Zod>>, 接口错误形式Zod extends z.ZodTypeAny, 接口正确形式Zod extends z.ZodTypeAny> extends __<路径类型, 方法类型, 逻辑类型, z.ZodObject<{
+    status: z.ZodLiteral<'fail'>;
+    data: 接口错误形式Zod;
+}>, 接口正确形式Zod, ___________<boolean, __________<逻辑类型>, __________$1<逻辑类型>>> {
+    constructor(请求路径: 路径类型, 请求方法: 方法类型, 接口逻辑: 逻辑类型, 逻辑错误类型Zod: 接口错误形式Zod, 逻辑正确类型Zod: 接口正确形式Zod);
+}
+
+export { 常用延时直接形式接口封装 };

package/dist/esm/wrapper/deferred-result-wrapper.js

@@ -0,0 +1,8 @@
+import {
+  常用延时直接形式接口封装
+} from "../chunk-TNQ5YSCZ.js";
+import "../chunk-JMR7QAHO.js";
+import "../chunk-6I3OJQWA.js";
+export {
+  \u5E38\u7528\u5EF6\u65F6\u76F4\u63A5\u5F62\u5F0F\u63A5\u53E3\u5C01\u88C5
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lsby/net-core",
-  "version": "0.6.6",
+  "version": "0.6.7-beta.10",
   "type": "module",
   "exports": {
     "require": "./dist/cjs/index.cjs",