@lsby/net-core 0.11.2 → 0.13.3

package/dist/cjs/action/action.bak.cjs

@@ -1,158 +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/action/action.bak.ts
-var action_bak_exports = {};
-__export(action_bak_exports, {
-  \u4E1A\u52A1\u884C\u4E3A: () => \u4E1A\u52A1\u884C\u4E3A
-});
-module.exports = __toCommonJS(action_bak_exports);
-var import_ts_fp_data = require("@lsby/ts-fp-data");
-var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
-  // ================================= 静态 =================================
-  static \u901A\u8FC7\u5B9E\u73B0\u6784\u9020(\u5B9E\u73B0) {
-    return new class extends _\u4E1A\u52A1\u884C\u4E3A {
-      async \u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570) {
-        return \u5B9E\u73B0(\u53C2\u6570);
-      }
-    }();
-  }
-  static \u901A\u8FC7\u6B63\u786E\u503C\u6784\u9020(a) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async () => new import_ts_fp_data.Right(a));
-  }
-  static \u901A\u8FC7\u9519\u8BEF\u503C\u6784\u9020(a) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async () => new import_ts_fp_data.Left(a));
-  }
-  static \u6D41\u5F0F\u7EC4\u5408(a, b) {
-    return a.\u6D41\u5F0F\u7EC4\u5408(b);
-  }
-  static \u6DF7\u5408\u7EC4\u5408(a, b) {
-    return a.\u6DF7\u5408\u7EC4\u5408(b);
-  }
-  /**
-   * 对多个项混合组合
-   */
-  static \u6DF7\u5408\u7EC4\u5408\u591A\u9879(arr) {
-    return arr.reduce((s, a) => s.\u6DF7\u5408\u7EC4\u5408(a));
-  }
-  /**
-   * 同时运行多个行为, 并提供一个函数处理它们的结果
-   * 如果其中任何一个行为发生错误, 则最终行为输出第一个错误
-   * 处理函数的类型是: 所有行为的结果合并 => 泛型A
-   * 新行为的类型是:
-   * - 参数: 所有行为的参数合并
-   * - 错误: 所有行为的错误合并
-   * - 返回值: 泛型A
-   */
-  static \u5E76\u884C\u7EC4\u5408(arr, f) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
-      let \u6240\u6709\u7ED3\u679C = await Promise.all(arr.map((a) => a.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570)));
-      let \u9519\u8BEF = \u6240\u6709\u7ED3\u679C.filter((a) => a.isLeft())[0] ?? null;
-      if (\u9519\u8BEF !== null) return \u9519\u8BEF;
-      let \u6B63\u786E\u7ED3\u679C\u5408\u5E76 = \u6240\u6709\u7ED3\u679C.map((a) => a.assertRight().getRight()).reduce((s, a) => ({ ...s, ...a }), {});
-      return new import_ts_fp_data.Right(await f(\u6B63\u786E\u7ED3\u679C\u5408\u5E76));
-    });
-  }
-  // ================================= 设置 =================================
-  \u8BBE\u7F6E\u53C2\u6570(\u8BBE\u7F6E\u53C2\u6570) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
-      return await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0({ ...\u8BBE\u7F6E\u53C2\u6570, ...\u53C2\u6570 });
-    });
-  }
-  // ================================= 运行 =================================
-  /**
-   * 运行业务行为, 如果抛出错误, 则原封不动向上抛出
-   */
-  async \u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570) {
-    return await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
-  }
-  /**
-   * 运行业务行为, 如果抛出错误, 则将错误值强制转换为字符串, 并包装为Error抛出
-   */
-  async \u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A\u5E76\u5305\u88C5(\u53C2\u6570) {
-    try {
-      return await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
-    } catch (e) {
-      throw new Error(String(e));
-    }
-  }
-  // ================================= 组合 =================================
-  /**
-   * 将两个行为串接, 得到一个新行为, 新行为的类型是:
-   * - 参数: a行为的参数
-   * - 错误: a行为的错误+b行为的错误
-   * - 返回值: b行为的返回值
-   */
-  \u6D41\u5F0F\u7EC4\u5408(b) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
-      let \u6211\u7684\u7ED3\u679C = await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
-      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft());
-      return b.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u6211\u7684\u7ED3\u679C.assertRight().getRight());
-    });
-  }
-  /**
-   * 将两个行为串接, 得到一个新的行为
-   * 相比流式组合, 本函数不要求串联位置参数匹配, 缺少的参数将在调用时补全
-   * 新行为的类型是:
-   * - 参数: a行为的参数+(b行为的参数-a行为的返回值)
-   * - 错误: a行为的错误+b行为的错误
-   * - 返回值: a行为的返回值+b行为的返回值
-   */
-  \u6DF7\u5408\u7EC4\u5408(b) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
-      let \u6211\u7684\u7ED3\u679C = await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
-      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft());
-      let \u5BF9\u65B9\u7ED3\u679C = await b.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0({ ...\u53C2\u6570, ...\u6211\u7684\u7ED3\u679C.assertRight().getRight() });
-      return \u5BF9\u65B9\u7ED3\u679C.map((a) => ({ ...a, ...\u6211\u7684\u7ED3\u679C.assertRight().getRight() }));
-    });
-  }
-  // ================================= 映射 =================================
-  \u6620\u5C04\u7ED3\u679C(f) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
-      let \u6211\u7684\u7ED3\u679C = await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
-      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft());
-      return import_ts_fp_data.Either.pure(f(\u6211\u7684\u7ED3\u679C.assertRight().getRight()));
-    });
-  }
-  \u6620\u5C04\u9519\u8BEF(f) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
-      let \u6211\u7684\u7ED3\u679C = await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
-      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(f(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft()));
-      return import_ts_fp_data.Either.pure(\u6211\u7684\u7ED3\u679C.assertRight().getRight());
-    });
-  }
-  /**
-   * 产生一个代数效应, 在效应中执行当前业务行为, 然后将其正确结果映射为新业务行为
-   * 新行为的类型是:
-   * - 参数: 必须是已有行为的参数的扩展, 因为调用时必须先调用已有行为
-   * - 错误: 已有行为的错误+自定义错误, 因为调用已有行为时可能出错
-   * - 返回值: 自定义数据
-   */
-  \u7ED1\u5B9A(f) {
-    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
-      let \u6211\u7684\u7ED3\u679C = await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
-      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft());
-      return f(\u6211\u7684\u7ED3\u679C.assertRight().getRight()).\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
-    });
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  \u4E1A\u52A1\u884C\u4E3A
-});

package/dist/cjs/action/action.bak.d.cts

@@ -1,99 +0,0 @@
-import { Either } from '@lsby/ts-fp-data';
-
-type 业务行为错误类型 = string | never;
-type 业务行为参数类型 = Record<string, any>;
-type 业务行为返回类型 = Record<string, any>;
-type 任意业务行为 = 业务行为<any, any, any>;
-type 计算混合组合<A参数类型 extends 业务行为参数类型, A错误类型 extends 业务行为错误类型, A返回类型 extends 业务行为返回类型, B参数类型 extends 业务行为参数类型, B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型> = 业务行为<A参数类型 & Omit<B参数类型, keyof A返回类型>, A错误类型 | B错误类型, A返回类型 & B返回类型>;
-type 计算混合单一组合<A, B> = A extends 业务行为<infer A参数, infer A错误, infer A返回> ? B extends 业务行为<infer B参数, infer B错误, infer B返回> ? 计算混合组合<A参数, A错误, A返回, B参数, B错误, 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]> : undefined;
-type 计算合并<Arr> = Arr extends [] ? 业务行为<{}, never, {}> : Arr extends [infer x, ...infer xs] ? x extends 业务行为<infer 参数1, infer 错误1, infer 返回1> ? 计算合并<xs> extends 业务行为<infer 参数2, infer 错误2, infer 返回2> ? 业务行为<参数1 & 参数2, 错误1 | 错误2, 返回1 & 返回2> : never : never : never;
-type 计算业务行为参数<A> = A extends 业务行为<infer 参数, infer _错误, infer _返回> ? 参数 : never;
-type 计算业务行为错误<A> = A extends 业务行为<infer _参数, infer 错误, infer _返回> ? 错误 : never;
-type 计算业务行为返回<A> = A extends 业务行为<infer _参数, infer _错误, infer 返回> ? 返回 : never;
-/**
- * # 业务行为
- *
- * 业务行为是代码中业务逻辑的抽象表示
- * 其本质是一个执行特定业务逻辑的函数
- *
- * ## 特点
- *
- * 其特点是:
- * - 业务相关: 比起普通函数, 特化了一部分逻辑, 以更好的适应业务逻辑的需要
- * - 类型安全: 严格的类型控制
- * - 可组合: 基于该模型, 可以创建出各种具有想象力的组合模式
- *
- * ## 实现
- *
- * 对于业务行为而言, 至少应该明确:
- * - 参数: 该函数需要的信息, 必须是对象
- * - 错误: 该函数可能发生的错误, 错误只能是字符串, 如果不可能产生错误使用never
- * - 返回: 该函数正确执行时返回的数据, 必须是对象
- *
- * 当编写一个业务行为时, 必须先明确以上类型, 然后继承该基类进行实现
- *
- * 实现中, 可以获得调用时提供的参数.
- * 实现中, 必须返回一个左值或一个右值, 当然也可能意外抛出错误
- * 当意外的抛出错误时, 不同的调用方法处理不一样
- */
-declare abstract class 业务行为<参数类型 extends 业务行为参数类型, 错误类型 extends 业务行为错误类型, 返回类型 extends 业务行为返回类型> {
-    static 通过实现构造<参数类型 extends 业务行为参数类型, 错误类型 extends 业务行为错误类型, 返回类型 extends 业务行为返回类型>(实现: (参数: 参数类型) => Promise<Either<错误类型, 返回类型>>): 业务行为<参数类型, 错误类型, 返回类型>;
-    static 通过正确值构造<参数类型 extends 业务行为参数类型, 错误类型 extends 业务行为错误类型, 返回类型 extends 业务行为返回类型>(a: 返回类型): 业务行为<参数类型, 错误类型, 返回类型>;
-    static 通过错误值构造<参数类型 extends 业务行为参数类型, 错误类型 extends 业务行为错误类型, 返回类型 extends 业务行为返回类型>(a: 错误类型): 业务行为<参数类型, 错误类型, 返回类型>;
-    static 流式组合<A参数类型 extends 业务行为参数类型, A错误类型 extends 业务行为错误类型, A返回类型 extends 业务行为返回类型, B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(a: 业务行为<A参数类型, A错误类型, A返回类型>, b: 业务行为<A返回类型, B错误类型, B返回类型>): 业务行为<A参数类型, A错误类型 | B错误类型, B返回类型>;
-    static 混合组合<A参数类型 extends 业务行为参数类型, A错误类型 extends 业务行为错误类型, A返回类型 extends 业务行为返回类型, B参数类型 extends 业务行为参数类型, B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(a: 业务行为<A参数类型, A错误类型, A返回类型>, b: 业务行为<B参数类型, B错误类型, B返回类型>): 计算混合组合<A参数类型, A错误类型, A返回类型, B参数类型, B错误类型, B返回类型>;
-    /**
-     * 对多个项混合组合
-     */
-    static 混合组合多项<A extends 任意业务行为[]>(arr: [...A]): 计算混合组合数组<A>;
-    /**
-     * 同时运行多个行为, 并提供一个函数处理它们的结果
-     * 如果其中任何一个行为发生错误, 则最终行为输出第一个错误
-     * 处理函数的类型是: 所有行为的结果合并 => 泛型A
-     * 新行为的类型是:
-     * - 参数: 所有行为的参数合并
-     * - 错误: 所有行为的错误合并
-     * - 返回值: 泛型A
-     */
-    static 并行组合<X extends 任意业务行为[], A extends 业务行为返回类型>(arr: [...X], f: (a: 计算业务行为返回<计算合并<X>>) => Promise<A>): 业务行为<计算业务行为参数<计算合并<X>>, 计算业务行为错误<计算合并<X>>, A>;
-    protected _业务行为实现_不变标注?: (参数: 参数类型) => Promise<Either<错误类型, 返回类型>>;
-    protected abstract 业务行为实现(参数: 参数类型): Promise<Either<错误类型, 返回类型>>;
-    设置参数<A extends Partial<参数类型>>(设置参数: A): 业务行为<Omit<参数类型, keyof A>, 错误类型, 返回类型>;
-    /**
-     * 运行业务行为, 如果抛出错误, 则原封不动向上抛出
-     */
-    运行业务行为(参数: 参数类型): Promise<Either<错误类型, 返回类型>>;
-    /**
-     * 运行业务行为, 如果抛出错误, 则将错误值强制转换为字符串, 并包装为Error抛出
-     */
-    运行业务行为并包装(参数: 参数类型): Promise<Either<错误类型, 返回类型>>;
-    /**
-     * 将两个行为串接, 得到一个新行为, 新行为的类型是:
-     * - 参数: a行为的参数
-     * - 错误: a行为的错误+b行为的错误
-     * - 返回值: b行为的返回值
-     */
-    流式组合<B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(b: 业务行为<返回类型, B错误类型, B返回类型>): 业务行为<参数类型, 错误类型 | B错误类型, B返回类型>;
-    /**
-     * 将两个行为串接, 得到一个新的行为
-     * 相比流式组合, 本函数不要求串联位置参数匹配, 缺少的参数将在调用时补全
-     * 新行为的类型是:
-     * - 参数: a行为的参数+(b行为的参数-a行为的返回值)
-     * - 错误: a行为的错误+b行为的错误
-     * - 返回值: a行为的返回值+b行为的返回值
-     */
-    混合组合<B参数类型 extends 业务行为参数类型, B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(b: 业务行为<B参数类型, B错误类型, B返回类型>): 计算混合组合<参数类型, 错误类型, 返回类型, B参数类型, B错误类型, B返回类型>;
-    映射结果<新返回类型 extends 业务行为返回类型>(f: (a: 返回类型) => 新返回类型): 业务行为<参数类型, 错误类型, 新返回类型>;
-    映射错误<新错误类型 extends 业务行为错误类型>(f: (a: 错误类型) => 新错误类型): 业务行为<参数类型, 新错误类型, 返回类型>;
-    /**
-     * 产生一个代数效应, 在效应中执行当前业务行为, 然后将其正确结果映射为新业务行为
-     * 新行为的类型是:
-     * - 参数: 必须是已有行为的参数的扩展, 因为调用时必须先调用已有行为
-     * - 错误: 已有行为的错误+自定义错误, 因为调用已有行为时可能出错
-     * - 返回值: 自定义数据
-     */
-    绑定<新参数类型 extends 业务行为参数类型 & 参数类型, 新错误类型 extends 错误类型 | 业务行为错误类型, 新返回类型 extends 业务行为返回类型>(f: (a: 返回类型) => 业务行为<新参数类型, 新错误类型, 新返回类型>): 业务行为<新参数类型, 新错误类型, 新返回类型>;
-}
-
-export { 业务行为, type 业务行为参数类型, type 业务行为返回类型, type 业务行为错误类型, type 计算业务行为参数, type 计算业务行为返回, type 计算业务行为错误 };

package/dist/cjs/bin/gen-api-list/test.cjs

@@ -1 +0,0 @@
-"use strict";

package/dist/cjs/bin/gen-api-list/test.d.cts

@@ -1,2 +0,0 @@
-
-export {  }

package/dist/cjs/bin/gen-api-type/test.cjs

@@ -1 +0,0 @@
-"use strict";

package/dist/cjs/bin/gen-api-type/test.d.cts

@@ -1,2 +0,0 @@
-
-export {  }

package/dist/cjs/global/global.cjs

@@ -1,91 +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/global/global.ts
-var global_exports = {};
-__export(global_exports, {
-  Global: () => Global,
-  WebSocket\u7BA1\u7406\u5668: () => WebSocket\u7BA1\u7406\u5668
-});
-module.exports = __toCommonJS(global_exports);
-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({}))
-]);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Global,
-  WebSocket\u7BA1\u7406\u5668
-});

package/dist/cjs/global/global.d.cts

@@ -1,21 +0,0 @@
-import { GlobalService, GlobalItem } from '@lsby/ts-global';
-import { Log } from '@lsby/ts-log';
-import { WebSocket } from 'ws';
-
-type id = string;
-declare class WebSocket管理器 {
-    private 连接表;
-    private log;
-    private 清理函数表;
-    private 定时器ID;
-    constructor(连接表: Record<id, WebSocket | null>);
-    增加连接(id: id, ws句柄: WebSocket): void;
-    查询连接存在(id: string): boolean;
-    设置清理函数(id: string, 清理函数: () => Promise<void>): Promise<void>;
-    获得句柄(id: id): Promise<WebSocket | null>;
-    删除连接(id: string): void;
-    private 清理无效连接;
-}
-declare let Global: GlobalService<[GlobalItem<"log", Log>, GlobalItem<"WebSocket管理器", WebSocket管理器>]>;
-
-export { Global, WebSocket管理器 };

package/dist/cjs/interface/interface-result.cjs

@@ -1,65 +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/interface/interface-result.ts
-var interface_result_exports = {};
-__export(interface_result_exports, {
-  \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668: () => \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668,
-  \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668: () => \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668,
-  \u76F4\u63A5\u5F62\u5F0F\u8F6C\u6362\u5668: () => \u76F4\u63A5\u5F62\u5F0F\u8F6C\u6362\u5668
-});
-module.exports = __toCommonJS(interface_result_exports);
-var \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668 = class {
-};
-var \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668 = class extends \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668 {
-  \u5B9E\u73B0(\u6570\u636E) {
-    switch (\u6570\u636E.getTag()) {
-      case "Left": {
-        return { status: "fail", data: \u6570\u636E.assertLeft().getLeft() };
-      }
-      case "Right": {
-        return { status: "success", data: \u6570\u636E.assertRight().getRight() };
-      }
-      default: {
-        throw new Error("\u610F\u5916\u7684\u6570\u636E\u6807\u8BB0");
-      }
-    }
-  }
-};
-var \u76F4\u63A5\u5F62\u5F0F\u8F6C\u6362\u5668 = class extends \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668 {
-  \u5B9E\u73B0(\u6570\u636E) {
-    switch (\u6570\u636E.getTag()) {
-      case "Left": {
-        return { status: "fail", data: \u6570\u636E.assertLeft().getLeft() };
-      }
-      case "Right": {
-        return \u6570\u636E.assertRight().getRight().data;
-      }
-      default: {
-        throw new Error("\u610F\u5916\u7684\u6570\u636E\u6807\u8BB0");
-      }
-    }
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  \u5E38\u7528\u5F62\u5F0F\u8F6C\u6362\u5668,
-  \u63A5\u53E3\u7ED3\u679C\u8F6C\u6362\u5668,
-  \u76F4\u63A5\u5F62\u5F0F\u8F6C\u6362\u5668
-});

package/dist/cjs/interface/interface-result.d.cts

@@ -1,8 +0,0 @@
-import '@lsby/ts-fp-data';
-export { x as 任意接口结果转换器, 常 as 常用形式转换器, w as 接口结果转换器, 直 as 直接形式转换器 } from '../interface-base-gRngpxki.cjs';
-import 'zod';
-import 'express';
-import '../help/interior.cjs';
-import '@lsby/ts-log';
-import 'node:http';
-import './interface-retuen.cjs';

package/dist/cjs/interface/interface-retuen.cjs

@@ -1,49 +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/interface/interface-retuen.ts
-var interface_retuen_exports = {};
-__export(interface_retuen_exports, {
-  \u5E38\u7528\u8FD4\u56DE\u5668: () => \u5E38\u7528\u8FD4\u56DE\u5668,
-  \u63A5\u53E3\u7ED3\u679C\u8FD4\u56DE\u5668: () => \u63A5\u53E3\u7ED3\u679C\u8FD4\u56DE\u5668,
-  \u81EA\u5B9A\u4E49\u8FD4\u56DE\u5668: () => \u81EA\u5B9A\u4E49\u8FD4\u56DE\u5668
-});
-module.exports = __toCommonJS(interface_retuen_exports);
-var \u63A5\u53E3\u7ED3\u679C\u8FD4\u56DE\u5668 = class {
-};
-var \u5E38\u7528\u8FD4\u56DE\u5668 = class extends \u63A5\u53E3\u7ED3\u679C\u8FD4\u56DE\u5668 {
-  \u8FD4\u56DE(req, res, \u7ED3\u679C) {
-    res.send(\u7ED3\u679C);
-  }
-};
-var \u81EA\u5B9A\u4E49\u8FD4\u56DE\u5668 = class extends \u63A5\u53E3\u7ED3\u679C\u8FD4\u56DE\u5668 {
-  constructor(\u5B9E\u73B0\u51FD\u6570) {
-    super();
-    this.\u5B9E\u73B0\u51FD\u6570 = \u5B9E\u73B0\u51FD\u6570;
-  }
-  \u8FD4\u56DE(req, res, \u7ED3\u679C) {
-    return this.\u5B9E\u73B0\u51FD\u6570(req, res, \u7ED3\u679C);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  \u5E38\u7528\u8FD4\u56DE\u5668,
-  \u63A5\u53E3\u7ED3\u679C\u8FD4\u56DE\u5668,
-  \u81EA\u5B9A\u4E49\u8FD4\u56DE\u5668
-});

package/dist/cjs/interface/interface-retuen.d.cts

@@ -1,30 +0,0 @@
-import { Request, Response } from 'express';
-
-/**
- * 描述接口如何将转换器转换后的数据发送给客户端
- *
- * 这一层的存在使得数据格式和传输方式完全解耦:
- * - 相同的数据可以通过 JSON, XML, Protobuf 等不同格式发送
- * - 可以选择不同的传输方式: HTTP 响应, WebSocket, SSE, 文件下载等
- * - 可以设置相应头等数据
- */
-declare abstract class 接口结果返回器<接口正确形式> {
-    abstract 返回(req: Request, res: Response, 结果: 接口正确形式): void | Promise<void>;
-}
-type 任意接口结果返回器 = 接口结果返回器<any>;
-/**
- * 常用返回器: 直接使用 res.send 发送数据
- */
-declare class 常用返回器<正确形式> extends 接口结果返回器<正确形式> {
-    返回(req: Request, res: Response, 结果: 正确形式): void;
-}
-/**
- * 自定义返回器: 支持任意自定义的返回逻辑
- */
-declare class 自定义返回器<正确形式> extends 接口结果返回器<正确形式> {
-    private 实现函数;
-    constructor(实现函数: (req: Request, res: Response, 结果: 正确形式) => void | Promise<void>);
-    返回(req: Request, res: Response, 结果: 正确形式): void | Promise<void>;
-}
-
-export { type 任意接口结果返回器, 常用返回器, 接口结果返回器, 自定义返回器 };