@lsby/net-core 0.3.12 → 0.3.13

package/dist/cjs/extend/{wrap-json.d.cts → api-json-wrap.d.cts}

@@ -1,9 +1,12 @@
 import { z } from 'zod';
+import { Either } from '@lsby/ts-fp-data';
 import { 插件项类型 as _____ } from '../interface/plug.cjs';
-import { 接口类型抽象类 as _______ } from '../interface/type/interface-type-abstract.cjs';
-import { 正确JSON结果 as __JSON__, 错误JSON结果 as __JSON__$1 } from '../result/result.cjs';
+import { 接口类型抽象类 as _______, 接口类型错误结果 as ________, 接口类型正确结果 as ________$1 } from '../interface/type/interface-type-abstract.cjs';
+import { JSON接口基类 as JSON____ } from './api-json-base.cjs';
 import 'express';
-import '@lsby/ts-fp-data';
+import '../interface/inst/interface-abstract.cjs';
+import '../result/result.cjs';
+import '../interface/action/action.cjs';
 
 declare abstract class 包装的接口类型抽象类<路径 extends string, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确返回类型 extends z.ZodTypeAny, 错误返回类型 extends z.ZodTypeAny> extends _______<路径, 方法, 插件们, z.ZodObject<{
     status: z.ZodLiteral<'success'>;
@@ -24,6 +27,9 @@ declare abstract class 包装的接口类型抽象类<路径 extends string, 方
         data: 错误返回类型;
     }>;
 }
+type 任意的包装的接口类型 = 包装的接口类型抽象类<any, any, any, any, any>;
+type 取返回类型<A> = A extends 包装的接口类型抽象类<any, any, any, infer X, any> ? X : never;
+type 取错误类型<A> = A extends 包装的接口类型抽象类<any, any, any, any, infer X> ? X : never;
 declare class 包装的接口类型<路径 extends string, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确返回类型 extends z.ZodTypeAny, 错误返回类型 extends z.ZodTypeAny> extends 包装的接口类型抽象类<路径, 方法, 插件们, 正确返回类型, 错误返回类型> {
     private path;
     private method;
@@ -43,17 +49,10 @@ declare class 包装的接口类型<路径 extends string, 方法 extends 'get'
         data: 错误返回类型;
     }>;
 }
-declare class 包装的正确JSON结果<Data> extends __JSON__<{
-    status: 'success';
-    data: Data;
-}> {
-    constructor(data: Data);
-}
-declare class 包装的错误JSON结果<Data> extends __JSON__$1<{
-    status: 'fail';
-    data: Data;
-}> {
-    constructor(data: Data);
+declare abstract class JSON接口包装基类<接口类型描述 extends 任意的包装的接口类型> extends JSON____<接口类型描述> {
+    protected 构造正确返回(data: z.infer<取返回类型<接口类型描述>>): Either<z.infer<________<接口类型描述>>, z.infer<________$1<接口类型描述>>>;
+    protected 构造错误返回(data: z.infer<取错误类型<接口类型描述>>): Either<z.infer<________<接口类型描述>>, z.infer<________$1<接口类型描述>>>;
+    protected 构造包装返回(data: Either<z.infer<取错误类型<接口类型描述>>, z.infer<取返回类型<接口类型描述>>>): Either<z.infer<________<接口类型描述>>, z.infer<________$1<接口类型描述>>>;
 }
 
-export { 包装的接口类型, 包装的接口类型抽象类, 包装的正确JSON结果, 包装的错误JSON结果 };
+export { JSON接口包装基类, 包装的接口类型, 包装的接口类型抽象类 };

package/dist/cjs/index.cjs

@@ -31,12 +31,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   API\u63A5\u53E3\u57FA\u7C7B: () => API\u63A5\u53E3\u57FA\u7C7B,
+  JSON\u63A5\u53E3\u5305\u88C5\u57FA\u7C7B: () => JSON\u63A5\u53E3\u5305\u88C5\u57FA\u7C7B,
+  JSON\u63A5\u53E3\u57FA\u7C7B: () => JSON\u63A5\u53E3\u57FA\u7C7B,
   JSON\u89E3\u6790\u63D2\u4EF6: () => JSON\u89E3\u6790\u63D2\u4EF6,
   \u4E2D\u6587\u8DEF\u5F84\u652F\u6301\u63D2\u4EF6: () => \u4E2D\u6587\u8DEF\u5F84\u652F\u6301\u63D2\u4EF6,
   \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B: () => \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B,
   \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B: () => \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B,
-  \u5305\u88C5\u7684\u6B63\u786EJSON\u7ED3\u679C: () => \u5305\u88C5\u7684\u6B63\u786EJSON\u7ED3\u679C,
-  \u5305\u88C5\u7684\u9519\u8BEFJSON\u7ED3\u679C: () => \u5305\u88C5\u7684\u9519\u8BEFJSON\u7ED3\u679C,
   \u63A5\u53E3: () => \u63A5\u53E3,
   \u63A5\u53E3\u7C7B\u578B: () => \u63A5\u53E3\u7C7B\u578B,
   \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B: () => \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B,
@@ -55,11 +55,128 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/extend/wrap-json.ts
-var import_zod = require("zod");
+// src/interface/action/action.ts
+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, \u4E1A\u52A1\u884C\u4E3A\u540D\u79F0) {
+    return new class extends _\u4E1A\u52A1\u884C\u4E3A {
+      async \u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570) {
+        return \u5B9E\u73B0(\u53C2\u6570);
+      }
+    }(\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0);
+  }
+  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) => {
+        var \u6240\u6709\u7ED3\u679C = await Promise.all(arr.map((a) => a.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570)));
+        var \u9519\u8BEF = \u6240\u6709\u7ED3\u679C.filter((a) => a.isLeft())[0];
+        if (\u9519\u8BEF) return \u9519\u8BEF;
+        var \u6B63\u786E\u7ED3\u679C\u5408\u5E76 = \u6240\u6709\u7ED3\u679C.map((a) => a.assertRight().getRight()).reduce((s, a) => Object.assign(s, a), {});
+        return new import_ts_fp_data.Right(await f(\u6B63\u786E\u7ED3\u679C\u5408\u5E76));
+      },
+      `\u5E76\u884C\u7EC4\u5408(${arr.map((a) => a.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0).join(", ")})`
+    );
+  }
+  // ================================= 私有 =================================
+  \u4E1A\u52A1\u884C\u4E3A\u540D\u79F0;
+  constructor(\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0) {
+    if (!\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0) this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0 = this.constructor.name || "<\u533F\u540D>";
+    else this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0 = \u4E1A\u52A1\u884C\u4E3A\u540D\u79F0;
+  }
+  // ================================= 设置 =================================
+  \u8BBE\u7F6E\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0(\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0) {
+    this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0 = \u4E1A\u52A1\u884C\u4E3A\u540D\u79F0;
+    return this;
+  }
+  \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.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A({ ...\u8BBE\u7F6E\u53C2\u6570, ...\u53C2\u6570 });
+    }, this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0);
+  }
+  // ================================= 运行 =================================
+  async \u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570) {
+    try {
+      return await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
+    } catch (e) {
+      throw e;
+    }
+  }
+  // ================================= 组合 =================================
+  /**
+   * 将两个模型串接, 得到一个新模型, 新模型的类型是:
+   * - 参数: a模型的参数
+   * - 错误: a模型的错误+b模型的错误
+   * - 返回值: b模型的返回值
+   */
+  \u6D41\u5F0F\u7EC4\u5408(b) {
+    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
+      const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570);
+      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft());
+      return b.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u6211\u7684\u7ED3\u679C.assertRight().getRight());
+    }, `\u6D41\u5F0F\u7EC4\u5408(${this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0}, ${b.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0})`);
+  }
+  /**
+   * 将两个模型串接, 得到一个新的模型
+   * 相比流式组合, 本函数不要求串联位置参数匹配, 缺少的参数将在调用时补全
+   * 新模型的类型是:
+   * - 参数: 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) => {
+      const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570);
+      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft());
+      var \u5BF9\u65B9\u7ED3\u679C = await b.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A({ ...\u53C2\u6570, ...\u6211\u7684\u7ED3\u679C.assertRight().getRight() });
+      return \u5BF9\u65B9\u7ED3\u679C.map((a) => Object.assign(a, \u6211\u7684\u7ED3\u679C.assertRight().getRight()));
+    }, `\u6DF7\u5408\u7EC4\u5408(${this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0}, ${b.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0})`);
+  }
+  // ================================= 映射 =================================
+  \u6620\u5C04\u7ED3\u679C(f) {
+    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
+      const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\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()));
+    }, this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0);
+  }
+  \u6620\u5C04\u9519\u8BEF(f) {
+    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
+      const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\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());
+    }, this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0);
+  }
+};
 
-// src/interface/type/interface-type-abstract.ts
-var \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B = class {
+// src/interface/inst/interface-abstract.ts
+var API\u63A5\u53E3\u57FA\u7C7B = class extends \u4E1A\u52A1\u884C\u4E3A {
+  async API\u5B9E\u73B0(\u53C2\u6570) {
+    var c = await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
+    if (c.isLeft()) return this.\u5305\u88C5\u9519\u8BEF\u7ED3\u679C(c.assertLeft().getLeft());
+    return this.\u5305\u88C5\u6B63\u786E\u7ED3\u679C(c.assertRight().getRight());
+  }
 };
 
 // src/global/global.ts
@@ -114,7 +231,25 @@ var \u9519\u8BEFJSON\u7ED3\u679C = class extends \u9519\u8BEF\u7ED3\u679C {
   }
 };
 
-// src/extend/wrap-json.ts
+// src/extend/api-json-base.ts
+var JSON\u63A5\u53E3\u57FA\u7C7B = class extends API\u63A5\u53E3\u57FA\u7C7B {
+  \u5305\u88C5\u6B63\u786E\u7ED3\u679C(\u6570\u636E) {
+    return new \u6B63\u786EJSON\u7ED3\u679C(\u6570\u636E);
+  }
+  \u5305\u88C5\u9519\u8BEF\u7ED3\u679C(\u6570\u636E) {
+    return new \u9519\u8BEFJSON\u7ED3\u679C(\u6570\u636E);
+  }
+};
+
+// src/extend/api-json-wrap.ts
+var import_zod = require("zod");
+var import_ts_fp_data2 = require("@lsby/ts-fp-data");
+
+// src/interface/type/interface-type-abstract.ts
+var \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B = class {
+};
+
+// src/extend/api-json-wrap.ts
 var \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B = class extends \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B {
 };
 var \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B = class extends \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B {
@@ -142,51 +277,51 @@ var \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B = class extends \u5305\u88C5\u768
     return import_zod.z.object({ status: import_zod.z.literal("fail"), data: this.\u9519\u8BEF\u8FD4\u56DE\u7C7B\u578B });
   }
 };
-var \u5305\u88C5\u7684\u6B63\u786EJSON\u7ED3\u679C = class extends \u6B63\u786EJSON\u7ED3\u679C {
-  constructor(data) {
-    super({
-      status: "success",
-      data
-    });
+var JSON\u63A5\u53E3\u5305\u88C5\u57FA\u7C7B = class extends JSON\u63A5\u53E3\u57FA\u7C7B {
+  \u6784\u9020\u6B63\u786E\u8FD4\u56DE(data) {
+    return new import_ts_fp_data2.Right({ status: "success", data });
   }
-};
-var \u5305\u88C5\u7684\u9519\u8BEFJSON\u7ED3\u679C = class extends \u9519\u8BEFJSON\u7ED3\u679C {
-  constructor(data) {
-    super({
-      status: "fail",
-      data
-    });
+  \u6784\u9020\u9519\u8BEF\u8FD4\u56DE(data) {
+    return new import_ts_fp_data2.Left({ status: "fail", data });
+  }
+  \u6784\u9020\u5305\u88C5\u8FD4\u56DE(data) {
+    if (data.isLeft()) return new import_ts_fp_data2.Left({ status: "fail", data: data.assertLeft().getLeft() });
+    return new import_ts_fp_data2.Right({ status: "success", data: data.assertRight().getRight() });
   }
-};
-
-// src/interface/inst/interface-abstract.ts
-var API\u63A5\u53E3\u57FA\u7C7B = class {
 };
 
 // src/interface/inst/interface.ts
 var \u63A5\u53E3 = class extends API\u63A5\u53E3\u57FA\u7C7B {
-  constructor(\u63A5\u53E3\u7C7B\u578B2, \u5B9E\u73B0) {
+  constructor(\u63A5\u53E3\u7C7B\u578B2, \u6B63\u786E\u7ED3\u679C\u5305\u88C5\u5668, \u9519\u8BEF\u7ED3\u679C\u5305\u88C5\u5668, \u5B9E\u73B0) {
     super();
     this.\u63A5\u53E3\u7C7B\u578B = \u63A5\u53E3\u7C7B\u578B2;
+    this.\u6B63\u786E\u7ED3\u679C\u5305\u88C5\u5668 = \u6B63\u786E\u7ED3\u679C\u5305\u88C5\u5668;
+    this.\u9519\u8BEF\u7ED3\u679C\u5305\u88C5\u5668 = \u9519\u8BEF\u7ED3\u679C\u5305\u88C5\u5668;
     this.\u5B9E\u73B0 = \u5B9E\u73B0;
   }
+  \u5305\u88C5\u6B63\u786E\u7ED3\u679C(a) {
+    return this.\u6B63\u786E\u7ED3\u679C\u5305\u88C5\u5668(a);
+  }
+  \u5305\u88C5\u9519\u8BEF\u7ED3\u679C(a) {
+    return this.\u9519\u8BEF\u7ED3\u679C\u5305\u88C5\u5668(a);
+  }
+  \u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570) {
+    return this.\u5B9E\u73B0(\u53C2\u6570);
+  }
   \u83B7\u5F97API\u7C7B\u578B() {
     return this.\u63A5\u53E3\u7C7B\u578B;
   }
-  API\u5B9E\u73B0(ctx) {
-    return this.\u5B9E\u73B0(ctx);
-  }
 };
 
 // src/interface/type/interface-type.ts
 var \u63A5\u53E3\u7C7B\u578B = class extends \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B {
-  constructor(\u8DEF\u5F84, \u65B9\u6CD5, \u63D2\u4EF6\u4EEC, \u6B63\u786E\u7ED3\u679C2, \u9519\u8BEF\u7ED3\u679C2) {
+  constructor(\u8DEF\u5F84, \u65B9\u6CD5, \u63D2\u4EF6\u4EEC, \u6B63\u786E\u7ED3\u679C3, \u9519\u8BEF\u7ED3\u679C3) {
     super();
     this.\u8DEF\u5F84 = \u8DEF\u5F84;
     this.\u65B9\u6CD5 = \u65B9\u6CD5;
     this.\u63D2\u4EF6\u4EEC = \u63D2\u4EF6\u4EEC;
-    this.\u6B63\u786E\u7ED3\u679C = \u6B63\u786E\u7ED3\u679C2;
-    this.\u9519\u8BEF\u7ED3\u679C = \u9519\u8BEF\u7ED3\u679C2;
+    this.\u6B63\u786E\u7ED3\u679C = \u6B63\u786E\u7ED3\u679C3;
+    this.\u9519\u8BEF\u7ED3\u679C = \u9519\u8BEF\u7ED3\u679C3;
   }
   \u83B7\u5F97\u8DEF\u5F84() {
     return this.\u8DEF\u5F84;
@@ -279,8 +414,7 @@ var \u8868\u5355\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
         })
       );
       const parseResult = t.safeParse({ body: req.body });
-      if (!parseResult.success)
-        throw new Error((0, import_node_util2.format)("parse url encoded body failed: %O", parseResult.error));
+      if (!parseResult.success) throw new Error((0, import_node_util2.format)("parse url encoded body failed: %O", parseResult.error));
       return { body: parseResult.data.body };
     });
   }
@@ -348,8 +482,7 @@ var \u670D\u52A1\u5668 = class {
     await new Promise((res, _rej) => {
       server = app.listen(this.\u7AEF\u53E3, () => res());
     });
-    if (server == null)
-      throw new Error("\u542F\u52A8\u670D\u52A1\u5668\u5931\u8D25");
+    if (server == null) throw new Error("\u542F\u52A8\u670D\u52A1\u5668\u5931\u8D25");
     return {
       ip: Object.values((0, import_node_os.networkInterfaces)()).flat().flatMap((address) => address !== void 0 ? [address] : []).map((wrappedAddress) => wrappedAddress.address).map((address) => `http://${address}:${this.\u7AEF\u53E3}`),
       server
@@ -390,12 +523,12 @@ var \u6D4B\u8BD5 = class extends \u6D4B\u8BD5\u62BD\u8C61\u7C7B {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   API\u63A5\u53E3\u57FA\u7C7B,
+  JSON\u63A5\u53E3\u5305\u88C5\u57FA\u7C7B,
+  JSON\u63A5\u53E3\u57FA\u7C7B,
   JSON\u89E3\u6790\u63D2\u4EF6,
   \u4E2D\u6587\u8DEF\u5F84\u652F\u6301\u63D2\u4EF6,
   \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B,
   \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B,
-  \u5305\u88C5\u7684\u6B63\u786EJSON\u7ED3\u679C,
-  \u5305\u88C5\u7684\u9519\u8BEFJSON\u7ED3\u679C,
   \u63A5\u53E3,
   \u63A5\u53E3\u7C7B\u578B,
   \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B,

package/dist/cjs/index.d.cts

@@ -1,8 +1,9 @@
-export { 包装的接口类型, 包装的接口类型抽象类, 包装的正确JSON结果, 包装的错误JSON结果 } from './extend/wrap-json.cjs';
+export { JSON接口基类 } from './extend/api-json-base.cjs';
+export { JSON接口包装基类, 包装的接口类型, 包装的接口类型抽象类 } from './extend/api-json-wrap.cjs';
 export { 接口 } from './interface/inst/interface.cjs';
-export { API接口基类, 任意接口, 计算实现参数, 计算实现结果 } from './interface/inst/interface-abstract.cjs';
+export { API接口基类, 任意接口, 计算实现参数, 计算实现返回 } from './interface/inst/interface-abstract.cjs';
 export { 接口类型 } from './interface/type/interface-type.cjs';
-export { 任意接口类型, 接口类型抽象类, 获得接口插件们 } from './interface/type/interface-type-abstract.cjs';
+export { 任意接口类型, 接口类型抽象类, 接口类型插件们, 接口类型方法, 接口类型正确结果, 接口类型路径, 接口类型错误结果, 获得接口插件们 } from './interface/type/interface-type-abstract.cjs';
 export { 任意插件, 包装插件项, 取插件内部类型, 合并插件结果, 插件, 插件项类型 } from './interface/plug.cjs';
 export { 中文路径支持插件 } from './plugin/chinese-path.cjs';
 export { 自定义数据插件 } from './plugin/custom-data.cjs';
@@ -13,6 +14,7 @@ export { 服务器 } from './server/server.cjs';
 export { 测试 } from './test/test.cjs';
 export { 测试抽象类 } from './test/test-abstract.cjs';
 import 'zod';
-import 'express';
 import '@lsby/ts-fp-data';
+import './interface/action/action.cjs';
+import 'express';
 import 'node:http';

package/dist/cjs/interface/action/action.cjs

@@ -0,0 +1,142 @@
+"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/action/action.ts
+var action_exports = {};
+__export(action_exports, {
+  \u4E1A\u52A1\u884C\u4E3A: () => \u4E1A\u52A1\u884C\u4E3A
+});
+module.exports = __toCommonJS(action_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, \u4E1A\u52A1\u884C\u4E3A\u540D\u79F0) {
+    return new class extends _\u4E1A\u52A1\u884C\u4E3A {
+      async \u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570) {
+        return \u5B9E\u73B0(\u53C2\u6570);
+      }
+    }(\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0);
+  }
+  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) => {
+        var \u6240\u6709\u7ED3\u679C = await Promise.all(arr.map((a) => a.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570)));
+        var \u9519\u8BEF = \u6240\u6709\u7ED3\u679C.filter((a) => a.isLeft())[0];
+        if (\u9519\u8BEF) return \u9519\u8BEF;
+        var \u6B63\u786E\u7ED3\u679C\u5408\u5E76 = \u6240\u6709\u7ED3\u679C.map((a) => a.assertRight().getRight()).reduce((s, a) => Object.assign(s, a), {});
+        return new import_ts_fp_data.Right(await f(\u6B63\u786E\u7ED3\u679C\u5408\u5E76));
+      },
+      `\u5E76\u884C\u7EC4\u5408(${arr.map((a) => a.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0).join(", ")})`
+    );
+  }
+  // ================================= 私有 =================================
+  \u4E1A\u52A1\u884C\u4E3A\u540D\u79F0;
+  constructor(\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0) {
+    if (!\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0) this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0 = this.constructor.name || "<\u533F\u540D>";
+    else this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0 = \u4E1A\u52A1\u884C\u4E3A\u540D\u79F0;
+  }
+  // ================================= 设置 =================================
+  \u8BBE\u7F6E\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0(\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0) {
+    this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0 = \u4E1A\u52A1\u884C\u4E3A\u540D\u79F0;
+    return this;
+  }
+  \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.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A({ ...\u8BBE\u7F6E\u53C2\u6570, ...\u53C2\u6570 });
+    }, this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0);
+  }
+  // ================================= 运行 =================================
+  async \u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570) {
+    try {
+      return await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
+    } catch (e) {
+      throw e;
+    }
+  }
+  // ================================= 组合 =================================
+  /**
+   * 将两个模型串接, 得到一个新模型, 新模型的类型是:
+   * - 参数: a模型的参数
+   * - 错误: a模型的错误+b模型的错误
+   * - 返回值: b模型的返回值
+   */
+  \u6D41\u5F0F\u7EC4\u5408(b) {
+    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
+      const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570);
+      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft());
+      return b.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u6211\u7684\u7ED3\u679C.assertRight().getRight());
+    }, `\u6D41\u5F0F\u7EC4\u5408(${this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0}, ${b.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0})`);
+  }
+  /**
+   * 将两个模型串接, 得到一个新的模型
+   * 相比流式组合, 本函数不要求串联位置参数匹配, 缺少的参数将在调用时补全
+   * 新模型的类型是:
+   * - 参数: 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) => {
+      const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570);
+      if (\u6211\u7684\u7ED3\u679C.isLeft()) return new import_ts_fp_data.Left(\u6211\u7684\u7ED3\u679C.assertLeft().getLeft());
+      var \u5BF9\u65B9\u7ED3\u679C = await b.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A({ ...\u53C2\u6570, ...\u6211\u7684\u7ED3\u679C.assertRight().getRight() });
+      return \u5BF9\u65B9\u7ED3\u679C.map((a) => Object.assign(a, \u6211\u7684\u7ED3\u679C.assertRight().getRight()));
+    }, `\u6DF7\u5408\u7EC4\u5408(${this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0}, ${b.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0})`);
+  }
+  // ================================= 映射 =================================
+  \u6620\u5C04\u7ED3\u679C(f) {
+    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
+      const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\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()));
+    }, this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0);
+  }
+  \u6620\u5C04\u9519\u8BEF(f) {
+    return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
+      const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\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());
+    }, this.\u4E1A\u52A1\u884C\u4E3A\u540D\u79F0);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  \u4E1A\u52A1\u884C\u4E3A
+});

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

@@ -0,0 +1,90 @@
+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, infer y] ? 计算混合单一组合<x, y> : Arr extends [infer x, infer y, ...infer s] ? 计算混合组合数组<[计算混合单一组合<x, y>, ...s]> : never;
+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;
+/**
+ * ## 业务行为
+ *
+ * 业务行为是代码中业务逻辑的抽象表示
+ * 其本质是一个执行特定业务逻辑的函数
+ * 其特点是:
+ * - 业务相关: 比起普通函数, 特化了一部分逻辑, 以更好的适应业务逻辑的需要
+ * - 类型安全: 遵循 先类型 后实现 的原则
+ * - 可组合: 基于该模型, 可以创建出各种具有想象力的组合模式
+ *
+ * ## 实现
+ *
+ * 对于业务行为而言, 至少应该明确:
+ * - 参数: 该函数需要的信息
+ * - 错误: 该函数可能发生的错误
+ * - 返回: 该函数正确执行时返回的数据
+ *
+ * 当编写一个业务行为时, 必须先明确以上值的类型, 然后继承该基类进行实现
+ *
+ * 实现中, 可以获得参数.
+ * 实现中, 必须返回一个左值或一个右值, 当然也可能意外抛出错误
+ * 当意外的抛出错误时, 会原封不动的抛出错误
+ *
+ * ## 组合
+ *
+ * 可以将业务逻辑进行组合, 创造出新的业务逻辑
+ *
+ * ## 使用
+ *
+ * 通过`运行业务行为`来执行该业务行为
+ * 这将会得到实现中返回的结果
+ */
+declare abstract class 业务行为<参数类型 extends 业务行为参数类型, 错误类型 extends 业务行为错误类型, 返回类型 extends 业务行为返回类型> {
+    static 通过实现构造<参数类型 extends 业务行为参数类型, 错误类型 extends 业务行为错误类型, 返回类型 extends 业务行为返回类型>(实现: (参数: 参数类型) => Promise<Either<错误类型, 返回类型>>, 业务行为名称?: string): 业务行为<参数类型, 错误类型, 返回类型>;
+    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>;
+    private 业务行为名称;
+    constructor(业务行为名称?: string);
+    protected abstract 业务行为实现(参数: 参数类型): Promise<Either<错误类型, 返回类型>>;
+    设置业务行为名称(业务行为名称: string): this;
+    设置参数<A extends Partial<参数类型>>(设置参数: A): 业务行为<Omit<参数类型, keyof A>, 错误类型, 返回类型>;
+    运行业务行为(参数: 参数类型): 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: 错误类型) => 新错误类型): 业务行为<参数类型, 新错误类型, 返回类型>;
+}
+
+export { 业务行为, type 业务行为参数类型, type 业务行为返回类型, type 业务行为错误类型 };