@lsby/net-core 0.11.2 → 0.13.3

package/dist/cjs/interface-base-gRngpxki.d.cts

@@ -1,235 +0,0 @@
-import { z } from 'zod';
-import { Either } from '@lsby/ts-fp-data';
-import { Request, Response } from 'express';
-import { 联合转元组 as _____ } from './help/interior.cjs';
-import { Log } from '@lsby/ts-log';
-import * as http from 'node:http';
-import { 接口结果返回器 as _______ } from './interface/interface-retuen.cjs';
-
-type 日志回调类型 = (level: 'trace' | 'debug' | 'info' | 'warn' | 'error', namespace: string, content: string) => Promise<void>;
-type 请求附加参数类型 = {
-    log: Log;
-    请求id: string;
-};
-declare class 服务器 {
-    private log;
-    private 日志回调?;
-    private 接口们;
-    private 端口;
-    private 静态资源路径;
-    private 默认get文件路径;
-    constructor(options: {
-        接口们: 任意接口[];
-        端口: number;
-        静态资源路径?: string;
-        默认get文件路径?: string;
-        日志回调?: 日志回调类型;
-    });
-    run(): Promise<{
-        ip: string[];
-        api: string[];
-        server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    }>;
-    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 插件项类型 = 插件<z.AnyZodObject>;
-type 取插件内部类型<A> = A extends 插件<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<取插件内部类型<插件项>> & 合并插件结果<xs> : {} : {} : {};
-
-type 清理函数类型<插件类型 extends 插件项类型[], 逻辑附加参数类型 extends 接口逻辑附加参数类型> = (参数: 合并插件结果<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: 请求附加参数类型) => Promise<void>;
-type 空对象 = Record<any, never>;
-type 兼容空对象 = Record<any, unknown>;
-type 接口逻辑错误类型 = Record<string, any> | string | never;
-type 接口逻辑正确类型 = Record<string, any>;
-type 接口逻辑附加参数类型 = Record<string, any>;
-/**
- * # 接口逻辑的基础抽象类
- *
- * - 该类表示一个接口的逻辑执行过程, 包括插件的运行, 结果的合并以及业务逻辑的实际执行.
- * - 插件提供预处理功能, 例如参数解析等, 它通过解析express的上下文, 获得结果并提供给实现.
- * - 实现函数负责业务逻辑的主要操作, 例如数据库查询等, 它接收插件的处理结果, 并返回计算结果(用Either表示).
- * - 运行时除了获得express上下文外, 还可以接收自定义参数, 称为`逻辑附加参数`.
- * - 每个接口逻辑实例可以通过一些方法与其他接口逻辑合并, 形成一个复杂的流程.
- *
- * ## 构造:
- *
- * - 可以通过继承该抽象类, 并实现抽象函数来使用.
- * - 也可以通过静态方法`构造`来直接进行构造.
- *
- * ## 组合
- *
- * 通过组合, 可以将简单的逻辑模块化, 并按需构建复杂的接口处理流程.
- *
- * ### 混合
- *
- * - 该类提供了`混合`方法, 用于将多个接口逻辑实例合成一个复合接口逻辑.
- *   - 组合的接口逻辑会按顺序依次被调用.
- *   - 如果某接口逻辑返回左值, 则整个结构将立即返回该左值.
- *   - 否则, 将右值内容注入上下文, 允许之后的接口逻辑通过`逻辑附加参数`访问它.
- *   - 最终将返回所有接口的结果的与.
- * - 这类似于monad的do结构, 在该结构中, 每个运行结果都会被注入到全局上下文并消除monad包装, 而语句可以使用上下文的值.
- *
- * ### 其他组合方法用到再写
- */
-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>(插件们: [...插件类型], 实现: (参数: 合并插件结果<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: 请求附加参数类型) => Promise<Either<错误类型, 返回类型>>, 清理函数: 清理函数类型<插件类型, 逻辑附加参数类型> | undefined, 上游接口逻辑: 上游接口类型, 最后接口逻辑: 最后接口类型): 接口逻辑Base<插件类型, 逻辑附加参数类型, 错误类型, 返回类型, 上游接口类型, 最后接口类型>;
-    static 构造<插件类型 extends 插件项类型[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型>(插件们: [...插件类型], 实现: (参数: 合并插件结果<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: 请求附加参数类型) => Promise<Either<错误类型, 返回类型>>, 清理函数?: 清理函数类型<插件类型, 逻辑附加参数类型> | undefined): 接口逻辑Base<插件类型, 逻辑附加参数类型, 错误类型, 返回类型, null, null>;
-    protected readonly __类型保持符号_协变?: [插件类型, 错误类型, 返回类型];
-    protected readonly __类型保持符号_逆变?: (a: 逻辑附加参数类型) => void;
-    constructor(上游接口: 上游接口类型, 最后接口: 最后接口类型);
-    计算插件结果(req: Request, res: Response, 请求附加参数: 请求附加参数类型): Promise<合并插件结果<插件类型>>;
-    abstract 获得插件们(): [...插件类型];
-    abstract 实现(参数: 合并插件结果<插件类型>, 逻辑附加参数: 逻辑附加参数类型, 请求附加参数: 请求附加参数类型): Promise<Either<错误类型, 返回类型>>;
-    获得清理函数?(): 清理函数类型<插件类型, 逻辑附加参数类型> | undefined;
-    通过插件结果运行(合并插件结果: 合并插件结果<插件类型>, 传入的逻辑附加参数: 逻辑附加参数类型, 传入的请求附加参数: 请求附加参数类型): Promise<Either<错误类型, 返回类型>>;
-    运行(req: Request, res: Response, 传入的逻辑附加参数: 逻辑附加参数类型, 传入的插件附加参数: 请求附加参数类型): Promise<Either<错误类型, 返回类型>>;
-    混合<输入的插件类型 extends 插件项类型[], 输入的错误类型 extends 接口逻辑错误类型, 输入的返回类型 extends 接口逻辑正确类型, 输入的上游接口逻辑类型 extends 任意接口逻辑 | null, 输入的最后接口逻辑类型 extends 任意接口逻辑 | null>(输入: 接口逻辑Base<输入的插件类型, 返回类型, 输入的错误类型, 输入的返回类型, 输入的上游接口逻辑类型, 输入的最后接口逻辑类型>): 接口逻辑Base<[
-        ...插件类型,
-        ...输入的插件类型
-    ], 逻辑附加参数类型, 错误类型 | 输入的错误类型, 返回类型 & 输入的返回类型, typeof this, typeof 输入>;
-    获得上游接口(): 上游接口类型;
-    获得最后接口(): 最后接口类型;
-}
-declare abstract class 接口逻辑<插件类型 extends 插件项类型[], 逻辑附加参数类型 extends 接口逻辑附加参数类型, 错误类型 extends 接口逻辑错误类型, 返回类型 extends 接口逻辑正确类型> extends 接口逻辑Base<插件类型, 逻辑附加参数类型, 错误类型, 返回类型, null, null> {
-    constructor();
-}
-type 任意接口逻辑 = 接口逻辑Base<any, any, any, any, any, any>;
-type 可调用接口逻辑 = 接口逻辑Base<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];
-};
-
-/**
- * 描述接口逻辑返回的数据将以何种形式返回给前端.
- */
-declare abstract class 接口结果转换器<实现错误类型 extends 接口逻辑错误类型, 实现正确类型 extends 接口逻辑正确类型, 接口错误形式, 接口正确形式> {
-    protected readonly __类型保持符号?: [实现错误类型, 实现正确类型, 接口错误形式, 接口正确形式];
-    abstract 实现(数据: Either<实现错误类型, 实现正确类型>): 接口错误形式 | 接口正确形式;
-}
-type 任意接口结果转换器 = 接口结果转换器<any, any, any, any>;
-/**
- * 常用形式转换器
- *
- * 将业务逻辑返回的 Either<错误, 成功> 转换为前端友好的统一格式:
- * - 成功时: { status: 'success', data: ... }
- * - 失败时: { status: 'fail', data: ... }
- *
- * 这种格式让前端可以通过 status 字段统一判断请求是否成功
- */
-declare class 常用形式转换器<实现错误类型 extends 接口逻辑错误类型, 实现正确类型 extends 接口逻辑正确类型> extends 接口结果转换器<实现错误类型, 实现正确类型, {
-    status: 'fail';
-    data: 实现错误类型;
-}, {
-    status: 'success';
-    data: 实现正确类型;
-}> {
-    实现(数据: Either<实现错误类型, 实现正确类型>): {
-        status: 'fail';
-        data: 实现错误类型;
-    } | {
-        status: 'success';
-        data: 实现正确类型;
-    };
-}
-/**
- * 直接形式转换器
- *
- * 将业务逻辑返回的 Either<错误, {data: ...}> 转换为直接格式:
- * - 成功时: 直接的 data 内容
- * - 失败时: { status: 'fail', data: ... }
- *
- * 用于需要直接返回的场景:
- * - 因为接口逻辑需要组合, 所以返回值必须是对象, 但有时候需要返回一个非对象数据
- * - 这个转换器就约定了一个模式, 用于返回直接结果
- * - 业务逻辑需要返回 Either<错误, 成功>, 其中成功部分必须是 { data: 真正的返回值 }
- * - 如果返回左值，返回标准错误格式 { status: 'fail', data: ... }
- * - 如果返回右值，直接返回 data 部分
- *
- * 典型应用场景:
- * - 文件下载: 直接返回文件流
- * - 图片/视频: 直接返回二进制数据
- * - SSE/WebSocket: 建立长连接
- */
-declare class 直接形式转换器<实现最终返回类型, 实现错误类型 extends 接口逻辑错误类型, 实现正确类型 extends {
-    data: 实现最终返回类型;
-}> 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>>, 接口结果返回器类型 extends _______<z.infer<接口正确形式Zod>>> {
-    private 请求路径;
-    private 请求方法;
-    private 接口逻辑;
-    private 接口错误形式Zod;
-    private 接口正确形式Zod;
-    private 结果转换器;
-    private 结果返回器;
-    protected readonly __类型保持符号?: [
-        路径类型,
-        方法类型,
-        逻辑类型,
-        接口错误形式Zod,
-        接口正确形式Zod,
-        接口结果转换器类型
-    ];
-    constructor(请求路径: 路径类型, 请求方法: 方法类型, 接口逻辑: 逻辑类型, 接口错误形式Zod: 接口错误形式Zod, 接口正确形式Zod: 接口正确形式Zod, 结果转换器: 接口结果转换器类型, 结果返回器: 接口结果返回器类型);
-    获得路径(): 路径类型;
-    获得方法(): 方法类型;
-    获得逻辑(): 逻辑类型;
-    获得接口错误形式Zod(): 接口错误形式Zod;
-    获得接口正确形式Zod(): 接口正确形式Zod;
-    获得结果转换器(): 接口结果转换器类型;
-    获得结果返回器(): 接口结果返回器类型;
-}
-type 任意接口 = 接口<any, any, any, any, any, any, any>;
-type 获得接口路径类型<A> = A extends 接口<infer X, any, any, any, any, any, any> ? X : never;
-type 获得接口方法类型<A> = A extends 接口<any, infer X, any, any, any, any, any> ? X : never;
-type 获得接口逻辑类型<A> = A extends 接口<any, any, infer X, any, any, any, any> ? X : never;
-type 获得接口错误形式<A> = A extends 接口<any, any, any, infer X, any, any, any> ? z.infer<X> : never;
-type 获得接口正确形式<A> = A extends 接口<any, any, any, any, infer X, any, any> ? z.infer<X> : never;
-type 获得接口结果转换器类型<A> = A extends 接口<any, any, any, any, any, infer X, any> ? X : never;
-type 获得接口结果返回器类型<A> = A extends 接口<any, any, any, any, any, any, infer X> ? X : never;
-
-export { type 取插件内部ts类型 as A, 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, type 接口逻辑附加参数类型 as k, 接口逻辑Base as l, 接口逻辑 as m, type 任意接口逻辑 as n, type 获得接口逻辑插件类型 as o, type 获得接口逻辑附加参数类型 as p, type 获得接口逻辑错误类型 as q, type 获得接口逻辑正确类型 as r, type 获得接口逻辑上游接口类型 as s, type 获得接口逻辑最后接口类型 as t, type 计算接口逻辑错误结果 as u, type 计算接口逻辑正确结果 as v, 接口结果转换器 as w, type 任意接口结果转换器 as x, type 任意插件 as y, type 插件项类型 as z, type 任意接口 as 任, type 兼容空对象 as 兼, type 取插件内部类型 as 取, type 可调用接口逻辑 as 可, type 合并插件结果 as 合, 常用形式转换器 as 常, type 接口路径类型 as 接, 插件 as 插, type 日志回调类型 as 日, 服务器 as 服, type 清理函数类型 as 清, 直接形式转换器 as 直, type 空对象 as 空, type 获得接口路径类型 as 获, type 计算接口逻辑参数 as 计, type 请求附加参数类型 as 请 };

package/dist/cjs/plugin/extend/custom-data.d.cts

@@ -1,17 +0,0 @@
-import { z } from 'zod';
-import { 插 as __ } from '../../interface-base-gRngpxki.cjs';
-import '@lsby/ts-fp-data';
-import 'express';
-import '../../help/interior.cjs';
-import '@lsby/ts-log';
-import 'node:http';
-import '../../interface/interface-retuen.cjs';
-
-/**
- * 该插件允许使用者给定任意的数据, 该数据将作为该插件的返回值, 最终传入到接口逻辑中
- */
-declare class 自定义数据插件<Data extends z.AnyZodObject> extends __<Data> {
-    constructor(t: Data, data: z.infer<Data>);
-}
-
-export { 自定义数据插件 };

package/dist/cjs/plugin/extend/json.d.cts

@@ -1,25 +0,0 @@
-import express from 'express';
-import { AnyZodObject, z } from 'zod';
-import { 严格递归合并对象 as ________ } from '../../help/help.cjs';
-import { 插 as __, z as _____, 取 as _______, o as __________ } from '../../interface-base-gRngpxki.cjs';
-import '@lsby/ts-fp-data';
-import '../../help/interior.cjs';
-import '@lsby/ts-log';
-import 'node:http';
-import '../../interface/interface-retuen.cjs';
-
-declare const 烙印: unique symbol;
-declare class JSON解析插件<Result extends AnyZodObject> extends __<z.ZodObject<{
-    body: Result;
-}>> {
-    private [烙印];
-    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解析插件项 ? ________<{
-    body: z.infer<_______<插件项>>['body'];
-}, 合并JSON插件结果<xs>> : 合并JSON插件结果<xs> : {} : {} : {};
-type 计算接口逻辑JSON参数<接口逻辑> = 合并JSON插件结果<__________<接口逻辑>>;
-
-export { JSON解析插件, type 任意JSON解析插件, type 任意JSON解析插件项, type 合并JSON插件结果, type 计算接口逻辑JSON参数 };

package/dist/cjs/plugin/extend/log-headers.d.cts

@@ -1,15 +0,0 @@
-import { z } from 'zod';
-import { 插 as __ } from '../../interface-base-gRngpxki.cjs';
-import '@lsby/ts-fp-data';
-import 'express';
-import '../../help/interior.cjs';
-import '@lsby/ts-log';
-import 'node:http';
-import '../../interface/interface-retuen.cjs';
-
-declare let zod类型表示: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-declare class 调试请求头插件 extends __<typeof zod类型表示> {
-    constructor();
-}
-
-export { 调试请求头插件 };

package/dist/cjs/plugin/extend/query.d.cts

@@ -1,25 +0,0 @@
-import { AnyZodObject, z } from 'zod';
-import { 严格递归合并对象 as ________ } from '../../help/help.cjs';
-import { 插 as __, z as _____, 取 as _______, o as __________ } from '../../interface-base-gRngpxki.cjs';
-import '@lsby/ts-fp-data';
-import 'express';
-import '../../help/interior.cjs';
-import '@lsby/ts-log';
-import 'node:http';
-import '../../interface/interface-retuen.cjs';
-
-declare const 烙印: unique symbol;
-declare class GET参数解析插件<Result extends AnyZodObject> extends __<z.ZodObject<{
-    query: Result;
-}>> {
-    private [烙印];
-    constructor(t: Result);
-}
-type 任意GET参数解析插件 = GET参数解析插件<any>;
-type 任意GET参数解析插件项 = 任意GET参数解析插件;
-type 合并GET插件结果<Arr extends Array<_____>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<_____> ? 插件项 extends 任意GET参数解析插件项 ? ________<{
-    query: z.infer<_______<插件项>>['query'];
-}, 合并GET插件结果<xs>> : 合并GET插件结果<xs> : {} : {} : {};
-type 计算接口逻辑GET参数<接口逻辑> = 合并GET插件结果<__________<接口逻辑>>;
-
-export { GET参数解析插件, type 任意GET参数解析插件, type 任意GET参数解析插件项, type 合并GET插件结果, type 计算接口逻辑GET参数 };

package/dist/cjs/plugin/extend/urlencoded.cjs

@@ -1,76 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/plugin/extend/urlencoded.ts
-var urlencoded_exports = {};
-__export(urlencoded_exports, {
-  \u8868\u5355\u89E3\u6790\u63D2\u4EF6: () => \u8868\u5355\u89E3\u6790\u63D2\u4EF6
-});
-module.exports = __toCommonJS(urlencoded_exports);
-var import_express = __toESM(require("express"), 1);
-var import_node_util = require("util");
-var import_zod = require("zod");
-
-// src/plugin/plug.ts
-var \u63D2\u4EF6 = class {
-  constructor(\u7C7B\u578B, \u5B9E\u73B0) {
-    this.\u7C7B\u578B = \u7C7B\u578B;
-    this.\u5B9E\u73B0 = \u5B9E\u73B0;
-  }
-  \u83B7\u5F97\u7C7B\u578B() {
-    return this.\u7C7B\u578B;
-  }
-  \u8FD0\u884C(req, res, \u9644\u52A0\u53C2\u6570) {
-    return this.\u5B9E\u73B0(req, res, \u9644\u52A0\u53C2\u6570);
-  }
-};
-
-// src/plugin/extend/urlencoded.ts
-var \u8868\u5355\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
-  constructor(t, opt) {
-    super(import_zod.z.object({ form: t }), async (req, res, \u9644\u52A0\u53C2\u6570) => {
-      let log = \u9644\u52A0\u53C2\u6570.log.extend("\u8868\u5355\u89E3\u6790\u63D2\u4EF6");
-      await new Promise(
-        (pRes, _rej) => import_express.default.urlencoded({ extended: true, ...opt })(req, res, () => {
-          pRes(null);
-        })
-      );
-      let parseResult = t.safeParse(req.body);
-      if (parseResult.success === false) {
-        await log.error("\u89E3\u6790url\u7F16\u7801\u6B63\u6587\u5931\u8D25: %o", parseResult.error);
-        throw new Error((0, import_node_util.format)("\u89E3\u6790url\u7F16\u7801\u6B63\u6587\u5931\u8D25: %o", parseResult.error));
-      }
-      return { form: parseResult.data };
-    });
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  \u8868\u5355\u89E3\u6790\u63D2\u4EF6
-});

package/dist/cjs/plugin/extend/urlencoded.d.cts

@@ -1,16 +0,0 @@
-import express from 'express';
-import { z } from 'zod';
-import { 插 as __ } from '../../interface-base-gRngpxki.cjs';
-import '@lsby/ts-fp-data';
-import '../../help/interior.cjs';
-import '@lsby/ts-log';
-import 'node:http';
-import '../../interface/interface-retuen.cjs';
-
-declare class 表单解析插件<Result extends z.AnyZodObject> extends __<z.ZodObject<{
-    form: Result;
-}>> {
-    constructor(t: Result, opt: Parameters<typeof express.urlencoded>[0]);
-}
-
-export { 表单解析插件 };

package/dist/cjs/plugin/extend/web-socket.cjs

@@ -1,168 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/plugin/extend/web-socket.ts
-var web_socket_exports = {};
-__export(web_socket_exports, {
-  WebSocket\u63D2\u4EF6: () => WebSocket\u63D2\u4EF6
-});
-module.exports = __toCommonJS(web_socket_exports);
-var import_ws2 = require("ws");
-var import_zod = require("zod");
-
-// src/global/global.ts
-var import_ts_global = require("@lsby/ts-global");
-var import_ts_log = require("@lsby/ts-log");
-var import_ws = require("ws");
-var log = new import_ts_log.Log("@lsby:net-core");
-var WebSocket\u7BA1\u7406\u5668 = class {
-  constructor(\u8FDE\u63A5\u8868) {
-    this.\u8FDE\u63A5\u8868 = \u8FDE\u63A5\u8868;
-    this.\u5B9A\u65F6\u5668ID = setInterval(
-      () => {
-        this.\u6E05\u7406\u65E0\u6548\u8FDE\u63A5().catch((err) => {
-          this.log.error(`\u6E05\u7406\u65E0\u6548\u8FDE\u63A5\u5931\u8D25: ${err}`).catch((a) => `\u65E5\u5FD7\u8F93\u51FA\u9519\u8BEF: ${a}: \u65E5\u5FD7\u5185\u5BB9: ${`\u6E05\u7406\u65E0\u6548\u8FDE\u63A5\u5931\u8D25: ${err}`}`);
-        });
-      },
-      5 * 60 * 1e3
-    );
-  }
-  log = log.extend("@lsby:net-core").extend("WebSocket\u7BA1\u7406\u5668");
-  \u6E05\u7406\u51FD\u6570\u8868 = {};
-  \u5B9A\u65F6\u5668ID = null;
-  \u589E\u52A0\u8FDE\u63A5(id, ws\u53E5\u67C4) {
-    this.\u8FDE\u63A5\u8868[id] = ws\u53E5\u67C4;
-  }
-  \u67E5\u8BE2\u8FDE\u63A5\u5B58\u5728(id) {
-    return this.\u8FDE\u63A5\u8868.hasOwnProperty(id) ? true : false;
-  }
-  async \u8BBE\u7F6E\u6E05\u7406\u51FD\u6570(id, \u6E05\u7406\u51FD\u6570) {
-    if (this.\u8FDE\u63A5\u8868.hasOwnProperty(id) === false) return;
-    this.\u6E05\u7406\u51FD\u6570\u8868[id] = \u6E05\u7406\u51FD\u6570;
-  }
-  async \u83B7\u5F97\u53E5\u67C4(id) {
-    return this.\u8FDE\u63A5\u8868[id] ?? null;
-  }
-  \u5220\u9664\u8FDE\u63A5(id) {
-    let \u6E05\u7406\u51FD\u6570 = this.\u6E05\u7406\u51FD\u6570\u8868[id];
-    try {
-      this.\u8FDE\u63A5\u8868[id]?.close(1e3, "\u670D\u52A1\u5668\u4E3B\u52A8\u5173\u95ED");
-    } catch (err) {
-      this.log.error(`\u5173\u95ED WebSocket \u53E5\u67C4\u5931\u8D25, id: ${id}, \u9519\u8BEF: ${err}`).catch((a) => `\u65E5\u5FD7\u8F93\u51FA\u9519\u8BEF: ${a}: \u65E5\u5FD7\u5185\u5BB9: ${`\u5173\u95ED WebSocket \u53E5\u67C4\u5931\u8D25, id: ${id}, \u9519\u8BEF: ${err}`}`);
-    }
-    \u6E05\u7406\u51FD\u6570?.().catch((err) => this.log.error(`\u6E05\u7406\u8FDE\u63A5\u5931\u8D25, id: ${id}, \u9519\u8BEF: ${err}`));
-    delete this.\u8FDE\u63A5\u8868[id];
-    delete this.\u6E05\u7406\u51FD\u6570\u8868[id];
-  }
-  async \u6E05\u7406\u65E0\u6548\u8FDE\u63A5() {
-    let \u6E05\u7406\u6570\u91CF = 0;
-    for (let [id, ws] of Object.entries(this.\u8FDE\u63A5\u8868)) {
-      if (ws === null || ws.readyState === import_ws.WebSocket.CLOSED) {
-        this.\u5220\u9664\u8FDE\u63A5(id);
-        \u6E05\u7406\u6570\u91CF++;
-      }
-    }
-    if (\u6E05\u7406\u6570\u91CF > 0) {
-      await this.log.info(`\u6E05\u7406\u4E86 ${\u6E05\u7406\u6570\u91CF} \u4E2A\u65E0\u6548 WebSocket \u8FDE\u63A5`);
-    }
-  }
-};
-var Global = new import_ts_global.GlobalService([
-  new import_ts_global.GlobalItem("log", log),
-  new import_ts_global.GlobalItem("WebSocket\u7BA1\u7406\u5668", new WebSocket\u7BA1\u7406\u5668({}))
-]);
-
-// src/plugin/plug.ts
-var \u63D2\u4EF6 = class {
-  constructor(\u7C7B\u578B, \u5B9E\u73B0) {
-    this.\u7C7B\u578B = \u7C7B\u578B;
-    this.\u5B9E\u73B0 = \u5B9E\u73B0;
-  }
-  \u83B7\u5F97\u7C7B\u578B() {
-    return this.\u7C7B\u578B;
-  }
-  \u8FD0\u884C(req, res, \u9644\u52A0\u53C2\u6570) {
-    return this.\u5B9E\u73B0(req, res, \u9644\u52A0\u53C2\u6570);
-  }
-};
-
-// src/plugin/extend/web-socket.ts
-var WebSocket\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
-  constructor(\u4FE1\u606F\u63CF\u8FF0) {
-    super(
-      import_zod.z.object({
-        ws\u64CD\u4F5C: import_zod.z.object({
-          \u53D1\u9001ws\u4FE1\u606F: import_zod.z.function(import_zod.z.tuple([\u4FE1\u606F\u63CF\u8FF0]), import_zod.z.promise(import_zod.z.void())),
-          \u5173\u95EDws\u8FDE\u63A5: import_zod.z.function(import_zod.z.tuple([]), import_zod.z.promise(import_zod.z.void())),
-          \u8BBE\u7F6E\u6E05\u7406\u51FD\u6570: import_zod.z.function(import_zod.z.tuple([import_zod.z.function(import_zod.z.tuple([]), import_zod.z.promise(import_zod.z.void()))]), import_zod.z.promise(import_zod.z.void()))
-        }).or(import_zod.z.null())
-      }),
-      async (req, _res, \u9644\u52A0\u53C2\u6570) => {
-        let log2 = \u9644\u52A0\u53C2\u6570.log.extend("webSocket\u63D2\u4EF6");
-        let WebSocket\u7BA1\u7406\u56682 = await Global.getItem("WebSocket\u7BA1\u7406\u5668");
-        let ws\u53E5\u67C4 = null;
-        let wsId = req.headers["ws-client-id"];
-        await log2.debug("\u68C0\u67E5 ws-client-id \u5934\u4FE1\u606F", { wsId });
-        if (typeof wsId !== "string") {
-          await log2.error("\u672A\u80FD\u83B7\u53D6\u5230\u6709\u6548\u7684 WebSocket Id");
-          return { ws\u64CD\u4F5C: null };
-        }
-        await log2.debug("\u5DF2\u83B7\u5F97 WebSocket Id: %o", wsId);
-        return {
-          ws\u64CD\u4F5C: {
-            async \u53D1\u9001ws\u4FE1\u606F(\u4FE1\u606F) {
-              if (ws\u53E5\u67C4 === null) {
-                ws\u53E5\u67C4 = await WebSocket\u7BA1\u7406\u56682.\u83B7\u5F97\u53E5\u67C4(wsId);
-              }
-              if (ws\u53E5\u67C4 === null) {
-                await log2.error("\u672A\u80FD\u83B7\u53D6\u5230\u6709\u6548\u7684 WebSocket \u53E5\u67C4");
-                return;
-              }
-              if (ws\u53E5\u67C4.readyState !== import_ws2.WebSocket.OPEN) {
-                await log2.warn("WebSocket \u672A\u6253\u5F00\uFF0C\u65E0\u6CD5\u53D1\u9001\u6D88\u606F", { wsId });
-                return;
-              }
-              await new Promise((resolve, reject) => {
-                ws\u53E5\u67C4?.send(JSON.stringify(\u4FE1\u606F), (err) => {
-                  if (err !== void 0 && err !== null) {
-                    log2.warn("\u53D1\u9001 WebSocket \u4FE1\u606F\u5931\u8D25", { \u9519\u8BEF: err }).catch((a) => `\u65E5\u5FD7\u8F93\u51FA\u9519\u8BEF: ${a}: \u65E5\u5FD7\u5185\u5BB9: ${`\u53D1\u9001 WebSocket \u4FE1\u606F\u5931\u8D25: ${err}`}`);
-                    return reject(err);
-                  }
-                  resolve();
-                });
-              });
-            },
-            async \u5173\u95EDws\u8FDE\u63A5() {
-              await log2.debug("\u5173\u95ED WebSocket \u8FDE\u63A5", { wsId });
-              WebSocket\u7BA1\u7406\u56682.\u5220\u9664\u8FDE\u63A5(wsId);
-            },
-            async \u8BBE\u7F6E\u6E05\u7406\u51FD\u6570(\u6E05\u7406\u51FD\u6570) {
-              await log2.debug("\u8BBE\u7F6E WebSocket \u6E05\u7406\u51FD\u6570", { wsId });
-              await WebSocket\u7BA1\u7406\u56682.\u8BBE\u7F6E\u6E05\u7406\u51FD\u6570(wsId, \u6E05\u7406\u51FD\u6570);
-            }
-          }
-        };
-      }
-    );
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WebSocket\u63D2\u4EF6
-});

package/dist/cjs/plugin/extend/web-socket.d.cts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import { 插 as __, z as _____ } from '../../interface-base-gRngpxki.cjs';
-import '@lsby/ts-fp-data';
-import 'express';
-import '../../help/interior.cjs';
-import '@lsby/ts-log';
-import 'node:http';
-import '../../interface/interface-retuen.cjs';
-
-declare class WebSocket插件<信息 extends z.AnyZodObject | z.ZodUnion<any>> extends __<z.ZodObject<{
-    ws操作: z.ZodUnion<[
-        z.ZodObject<{
-            发送ws信息: z.ZodFunction<z.ZodTuple<[信息], null>, z.ZodPromise<z.ZodVoid>>;
-            关闭ws连接: z.ZodFunction<z.ZodTuple<[], null>, z.ZodPromise<z.ZodVoid>>;
-            设置清理函数: z.ZodFunction<z.ZodTuple<[z.ZodFunction<z.ZodTuple<[], null>, z.ZodPromise<z.ZodVoid>>], null>, z.ZodPromise<z.ZodVoid>>;
-        }>,
-        z.ZodNull
-    ]>;
-}>> {
-    constructor(信息描述: 信息);
-}
-type 任意WS插件 = WebSocket插件<any>;
-type 任意WS插件项 = 任意WS插件;
-type 取WS插件泛型<A> = A extends WebSocket插件<infer x> ? x : never;
-type 取第一个WS插件结果<Arr extends Array<_____>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<_____> ? 插件项 extends 任意WS插件项 ? z.infer<取WS插件泛型<插件项>> : 取第一个WS插件结果<xs> : {} : {} : {};
-
-export { WebSocket插件, type 任意WS插件, type 任意WS插件项, type 取WS插件泛型, type 取第一个WS插件结果 };

package/dist/cjs/plugin/plug.d.cts

@@ -1,8 +0,0 @@
-import 'express';
-import 'zod';
-export { y as 任意插件, A as 取插件内部ts类型, 取 as 取插件内部类型, 合 as 合并插件结果, 插 as 插件, z as 插件项类型 } from '../interface-base-gRngpxki.cjs';
-import '@lsby/ts-fp-data';
-import '../help/interior.cjs';
-import '@lsby/ts-log';
-import 'node:http';
-import '../interface/interface-retuen.cjs';