gdmb 1.3.1 → 1.3.3

package/dist/gdmb.es.js

@@ -1,5 +1,5 @@
-import { container as l, Lifecycle as a, predicateAwareClassFactory as f, instancePerContainerCachingFactory as d, instanceCachingFactory as g } from "tsyringe";
-class m {
+import { container as l, Lifecycle as c, predicateAwareClassFactory as m, instancePerContainerCachingFactory as g, instanceCachingFactory as p } from "tsyringe";
+class C {
   /**
    * 事件容器
    */
@@ -23,20 +23,20 @@ class m {
    * @param handler 处理器
    * @returns 监听句柄
    */
-  on(e, s) {
-    const r = this._mapper[e];
-    r ? r.push(s) : (this.register(e), this.on(e, s));
+  on(e, t) {
+    const s = this._mapper[e];
+    s ? s.push(t) : (this.register(e), this.on(e, t));
   }
   /**
    * 移出指定监听函数监听
    * @param eventName 事件名称
    * @param handler 监听函数
    */
-  off(e, s) {
-    const r = this._mapper[e];
-    if (r) {
-      const i = r.indexOf(s);
-      i !== -1 && r.splice(i, 1);
+  off(e, t) {
+    const s = this._mapper[e];
+    if (s) {
+      const i = s.indexOf(t);
+      i !== -1 && s.splice(i, 1);
     }
   }
   /**
@@ -44,11 +44,11 @@ class m {
    * @param eventName 事件名称
    * @param args 时间回调参数
    */
-  trigger(e, ...s) {
-    const r = this._mapper[e];
-    r && setTimeout(() => {
-      for (const i of Object.values(r))
-        i(...s);
+  trigger(e, ...t) {
+    const s = this._mapper[e];
+    s && setTimeout(() => {
+      for (const i of Object.values(s))
+        i(...t);
     }, 0);
   }
   /**
@@ -57,231 +57,7 @@ class m {
   constructor() {
   }
 }
-class _ {
-}
-class w {
-  /**
-   * @summary 领域内部依赖注入容器
-   * @description 领域内部依赖注入容器，用于注册和解析领域服务、实体、值对象等。
-   */
-  dic = l.createChildContainer();
-  /**
-   * @description 领域事件句柄，用于触发、监听、取消监听领域事件
-   */
-  e = new m();
-  /**
-   * @description 向领域依赖注入容器中注册一个或多个领域服务
-   * @param service 单个领域服务类或数组
-   * @param options 领域服务注册配置项，可传入领域服务构造参数以及配置依赖解决拦截器和频率等
-   * @example
-   * ```typescript
-   * class ServiceOne extends DomainService {
-   *
-   *   // before resolve 拦截器
-   *   public static beforeResolution(token: InjectionToken, resolutionType: string) {}
-   *
-   *   // after resolve 拦截器
-   *   public static afterResolution(token: InjectionToken, result: ServiceOne | ServiceOne[], resolutionType: string) {}
-   *
-   *   constructor(public arg: string, public arg2: number) {
-   *     super();
-   *   }
-   * }
-   *
-   * // 注册领域服务
-   * domain.registerService(ServiceOne, { beforeResolution: ServiceOne.beforeResolution, afterResolution: ServiceOne.afterResolution })
-   * ```
-   */
-  registerService(e, s) {
-    const r = Array.isArray(e) ? e : [e], i = s ? Array.isArray(s) ? s : [s] : [];
-    for (let n = 0; n < r.length; n += 1) {
-      const t = r[n], c = i[n];
-      if (this.dic.isRegistered(t.name) || this.dic.isRegistered(t)) {
-        console.warn(`服务 ${t.name} 已注册，跳过注册`);
-        continue;
-      }
-      this.dic.register(t.name, { useClass: t }), this.dic.register(t, { useClass: t }), c?.beforeResolution && (this.dic.beforeResolution(t.name, c.beforeResolution, {
-        frequency: c?.beforeResolutionFrequency || "Always"
-      }), this.dic.beforeResolution(t, c.beforeResolution, {
-        frequency: c?.beforeResolutionFrequency || "Always"
-      })), c?.afterResolution && (this.dic.afterResolution(t.name, c.afterResolution, {
-        frequency: c?.afterResolutionFrequency || "Always"
-      }), this.dic.afterResolution(t, c?.afterResolution, {
-        frequency: c?.afterResolutionFrequency || "Always"
-      }));
-    }
-  }
-  /**
-   * @description 向领域依赖注入容器中注册领域实体，指定缓存策略为'cache'时全局单例。
-   * @param entity 单个领域实体类或数组
-   * @param options 领域实体注册配置项
-   * @example
-   * ```typescript
-   * class EntityOne extends DomainEntity {
-   *
-   *   // before resolve 拦截器
-   *   public static beforeResolution(token: InjectionToken, resolutionType: string) {}
-   *
-   *   // after resolve 拦截器
-   *   public static afterResolution(token: InjectionToken, result: EntityOne | EntityOne[], resolutionType: string) {}
-   *
-   *   constructor(public arg: string, public arg2: number) {
-   *     super();
-   *   }
-   * }
-   *
-   * // 注册领域实体
-   * domain.registerEntity(EntityOne, { cachePolicy: 'cache', beforeResolution: EntityOne.beforeResolution, afterResolution: EntityOne.afterResolution })
-   * ```
-   */
-  registerEntity(e, s) {
-    const r = Array.isArray(e) ? e : [e], i = s ? Array.isArray(s) ? s : [s] : [];
-    for (let n = 0; n < r.length; n += 1) {
-      const t = r[n], c = i[n];
-      if (this.dic.isRegistered(t.name) || this.dic.isRegistered(t)) {
-        console.warn(`实体 ${t.name} 已注册，跳过注册`);
-        continue;
-      }
-      if (c?.cachePolicy)
-        switch (c.cachePolicy) {
-          case "cache":
-            l.register(t.name, { useClass: t }, { lifecycle: a.Singleton }), l.register(t, { useClass: t }, { lifecycle: a.Singleton });
-            break;
-          case "containerCache":
-            this.dic.register(t.name, { useClass: t }, { lifecycle: a.ContainerScoped }), this.dic.register(t, { useClass: t }, { lifecycle: a.ContainerScoped });
-            break;
-          case "resolution":
-            this.dic.register(t.name, { useClass: t }, { lifecycle: a.ResolutionScoped }), this.dic.register(t, { useClass: t }, { lifecycle: a.ResolutionScoped });
-            break;
-        }
-      else
-        this.dic.register(t.name, { useClass: t }, { lifecycle: a.Transient }), this.dic.register(t, { useClass: t }, { lifecycle: a.Transient });
-      c?.beforeResolution && (this.dic.beforeResolution(t.name, c.beforeResolution, {
-        frequency: "Always"
-      }), this.dic.beforeResolution(t, c.beforeResolution, {
-        frequency: "Always"
-      })), c?.afterResolution && (this.dic.afterResolution(t.name, c.afterResolution, {
-        frequency: "Always"
-      }), this.dic.afterResolution(t, c.afterResolution, {
-        frequency: "Always"
-      }));
-    }
-  }
-  /**
-   * @summary 项领域内依赖注入容器中注册值对象，当指定 factoryType 为'cache'时全局单例。
-   * @description 需要泛型类型 V，约束工厂函数返回类型，V 满足 VO 类型约束，不允许包含函数属性
-   * @param vos 值对象注册配置项
-   * @example
-   * ```typescript
-   * domain.registerVO({
-   *   token: 'VO1',
-   *   factoryType: 'cache',
-   *   resolveFactory: () => ({ date: '2023-01-01' })
-   * })
-   * ```
-   */
-  registerVO(e) {
-    const s = Array.isArray(e) ? e : [e];
-    for (let r = 0; r < s.length; r += 1) {
-      const i = s[r], n = Array.isArray(i.token) ? i.token : [i.token];
-      for (let t = 0; t < n.length; t += 1) {
-        const c = n[t];
-        switch (i.factoryType) {
-          case "cache":
-            l.register(c, { useFactory: g(i.resolveFactory) });
-            break;
-          case "containerCache":
-            this.dic.register(c, { useFactory: d(i.resolveFactory) });
-            break;
-          case "predicate":
-            this.dic.register(c, {
-              useFactory: f(
-                i.resolveFactory,
-                i.positiveTarget,
-                i.negativeTarget
-              )
-            });
-            break;
-          default:
-            this.dic.register(c, { useFactory: i.resolveFactory });
-            break;
-        }
-      }
-    }
-  }
-  /**
-   * @description 从依赖注入容器中获取领域服务实例对象
-   * @param token 领域服务token
-   * @returns 领域服务实例对象
-   */
-  services(e) {
-    const s = this.dic.resolve(e);
-    return s && !s?.e && (s.e = this.e), s;
-  }
-  /**
-   * @description 从依赖注入容器中获取领域实体实例对象
-   * @param sourceToken 源领域实体token，存在适配器时是 DEF 泛型类型，否则为 DE 泛型类型
-   * @param adapter 领域实体适配器，将 DEF 类型转换为 DE 类型
-   * @returns 领域实体实例对象
-   */
-  entities(e, s) {
-    let r;
-    if (s) {
-      const i = this.dic.resolve(e);
-      r = s.transform(i);
-    } else
-      r = this.dic.resolve(e);
-    return r && !r?.e && (r.e = this.e), r;
-  }
-  /**
-   * @description 从依赖注入容器中获取领域值对象实例对象
-   * @param sourceToken 源领域值对象token，存在适配器时是 VF 泛型类型，否则为 V 泛型类型
-   * @param adapter 领域值对象适配器，将 VF 类型转换为 V 类型
-   * @returns 领域值对象实例对象
-   */
-  vos(e, s) {
-    if (s) {
-      const r = this.dic.resolve(e);
-      return s.transform(r);
-    } else
-      return this.dic.resolve(e);
-  }
-  /**
-   * 域基类构造函数
-   */
-  constructor() {
-  }
-}
-const y = (o) => (o.prototype.$ins = null, class extends o {
-  constructor(...e) {
-    return super(...e), o.prototype.$ins || (o.prototype.$ins = this), o.prototype.$ins;
-  }
-});
-var p = Object.getOwnPropertyDescriptor, v = (o, e, s, r) => {
-  for (var i = r > 1 ? void 0 : r ? p(e, s) : e, n = o.length - 1, t; n >= 0; n--)
-    (t = o[n]) && (i = t(i) || i);
-  return i;
-};
-let u = class {
-  /** 事件句柄 */
-  e = void 0;
-  /**
-   * 域基类构造函数
-   */
-  constructor() {
-  }
-};
-u = v([
-  y
-], u);
-class F {
-  /** 事件句柄 */
-  e = void 0;
-  /**
-   * 域基类构造函数
-   */
-  constructor() {
-  }
+class q {
 }
 class R {
   /**
@@ -303,12 +79,13 @@ class R {
   /**
    * 执行命令
    * @param command 要执行的命令
+   * @param pushToHistory 是否将命令推入历史记录，默认为 true
    */
-  execute(e) {
-    e.execute(), this.history.push({
+  execute(e, t = !0) {
+    e.execute(), t && (this.history.push({
       command: e,
       timestamp: Date.now()
-    }), this.undoHistory = [], this.history.length > this.maxHistoryDepth && this.history.shift();
+    }), this.undoHistory = [], this.history.length > this.maxHistoryDepth && this.history.shift());
   }
   /**
    * 撤销上一个命令
@@ -333,9 +110,10 @@ class R {
   /**
    * 批量执行命令
    * @param commands 要执行的命令数组
+   * @param pushToHistory 是否将命令推入历史记录，默认为 true
    */
-  executeBatch(e) {
-    e.forEach((s) => this.execute(s));
+  executeBatch(e, t = !0) {
+    e.forEach((s) => this.execute(s, t));
   }
   /**
    * 清空命令历史
@@ -376,10 +154,10 @@ class R {
    * @param option 命令调用者构造配置参数
    */
   constructor(e) {
-    this.maxHistoryDepth = e?.maxHistoryDepth || 1 / 0, this.maxUndoHistoryDepth = e?.maxUndoHistoryDepth || 1 / 0;
+    this.maxHistoryDepth = e?.maxHistoryDepth || 30, this.maxUndoHistoryDepth = e?.maxUndoHistoryDepth || 30;
   }
 }
-class C {
+class v {
   /**
    * 命令接收者
    */
@@ -396,15 +174,20 @@ class C {
    * 命令描述
    */
   description;
+  /**
+   * 原始命令字符串
+   */
+  commandString;
   /**
    * 构造函数
    * @param receiver 命令接收者
    * @param executeFn 执行操作的函数
    * @param undoFn 撤销操作的函数
    * @param description 命令描述
+   * @param commandString 原始命令字符串
    */
-  constructor(e, s, r, i) {
-    this.receiver = e, this.executeFn = s, this.undoFn = r, this.description = i;
+  constructor(e, t, s, i, o = "") {
+    this.receiver = e, this.executeFn = t, this.undoFn = s, this.description = i, this.commandString = o;
   }
   /**
    * 执行命令
@@ -425,32 +208,137 @@ class C {
   getDescription() {
     return this.description;
   }
+  /**
+   * 获取原始命令字符串
+   * @returns 命令字符串
+   */
+  getCommandString() {
+    return this.commandString;
+  }
+}
+function b(n, e, t, s, i = "") {
+  return new v(n, e, t, s, i);
 }
-function H(o, e, s, r) {
-  return new C(o, e, s, r);
+class H {
+  /** 命令注册映射 */
+  commands = /* @__PURE__ */ new Map();
+  /**
+   * 注册命令
+   * @param name 命令名
+   * @param receiver 命令接收者
+   * @param creator 命令创建函数
+   * @param description 命令描述
+   */
+  register(e, t, s) {
+    this.commands.set(e, { receiver: t, description: s });
+  }
+  /**
+   * 获取命令注册信息
+   */
+  get(e) {
+    return this.commands.get(e);
+  }
+  /**
+   * 列出所有已注册的命令
+   */
+  listCommands() {
+    return [...this.commands.entries()].map(([e, t]) => ({
+      name: e,
+      description: t.description
+    }));
+  }
 }
 class D {
+  /**
+   * 解析命令字符串
+   * @param commandString 命令字符串，如 "add -a 10 -b 5"
+   * @returns ParsedCommand 对象
+   */
+  parse(e) {
+    const t = e.trim().split(/\s+/g), s = t[0], i = /* @__PURE__ */ new Map();
+    for (let o = 1; o < t.length; o++) {
+      const r = t[o];
+      if (r.startsWith("-")) {
+        const a = r.slice(1);
+        if (o + 1 >= t.length || t[o + 1].startsWith("-"))
+          i.set(a, !0);
+        else {
+          const u = t[o + 1];
+          isNaN(Number(u)) ? i.set(a, u) : i.set(a, Number(u)), o++;
+        }
+      }
+    }
+    return {
+      commandName: s,
+      options: i,
+      args: t.slice(1)
+    };
+  }
+}
+class f {
   /**
    * 命令调用者
    */
   invoker;
+  /**
+   * 命令解析器
+   */
+  parser = new D();
+  /**
+   * 命令注册器
+   */
+  registry = new H();
+  /**
+   * 注册命令
+   * @param name 命令名称
+   * @param receiver 命令接收者
+   */
+  register(e) {
+    this.registry.register(e.name, e, e.description);
+  }
   /**
    * 创建命令
    * @param receiver 命令接收者
    * @param executeFn 执行操作的函数
    * @param undoFn 撤销操作的函数
    * @param description 命令描述
+   * @param commandString 原始命令字符串
    * @returns 命令对象
    */
-  create(e, s, r, i) {
-    return H(e, s, r, i);
+  create(e, t, s, i, o = "") {
+    return b(e, t, s, i, o);
+  }
+  /**
+   * 从命令字符串创建 Command
+   * @param commandString 命令字符串
+   * @param description 针对本次命令描述
+   * @returns Command 实例，失败返回 undefined
+   */
+  createFromCommandString(e, t) {
+    const s = this.parser.parse(e), i = this.registry.get(s.commandName);
+    if (!i) {
+      console.warn(`命令 ${s.commandName} 未注册`);
+      return;
+    }
+    return i.receiver.creator?.(
+      s.options,
+      s.args,
+      t || i.description,
+      e
+    );
   }
   /**
    * 执行命令
    * @param command 要执行的命令
+   * @param description 针对本次命令描述
+   * @param pushToHistory 是否将命令推入历史记录，默认为 true
    */
-  execute(e) {
-    this.invoker.execute(e);
+  execute(e, t, s = !0) {
+    if (typeof e == "string") {
+      const i = this.createFromCommandString(e, t);
+      i && this.invoker.execute(i, s);
+    } else
+      this.invoker.execute(e, s);
   }
   /**
    * 撤销上一个命令
@@ -469,9 +357,10 @@ class D {
   /**
    * 批量执行命令
    * @param commands 要执行的命令数组
+   * @param pushToHistory 是否将命令推入历史记录，默认为 true
    */
-  executeBatch(e) {
-    this.invoker.executeBatch(e);
+  executeBatch(e, t = !0) {
+    this.invoker.executeBatch(e, t);
   }
   /**
    * 清空命令历史
@@ -507,6 +396,12 @@ class D {
   getUndoHistoryCount() {
     return this.invoker.getUndoHistoryCount();
   }
+  /**
+   * 列出所有可用命令
+   */
+  listCommands() {
+    return this.registry.listCommands();
+  }
   /**
    * 构造函数
    * @param option 配置参数
@@ -518,12 +413,241 @@ class D {
     });
   }
 }
-var b = Object.getOwnPropertyDescriptor, x = (o, e, s, r) => {
-  for (var i = r > 1 ? void 0 : r ? b(e, s) : e, n = o.length - 1, t; n >= 0; n--)
-    (t = o[n]) && (i = t(i) || i);
+class k {
+  /**
+   * @summary 领域内部依赖注入容器
+   * @description 领域内部依赖注入容器，用于注册和解析领域服务、实体、值对象等。
+   */
+  dic = l.createChildContainer();
+  /**
+   * @description 领域事件句柄，用于触发、监听、取消监听领域事件
+   */
+  e = new C();
+  /**
+   * @description 领域命令句柄，用于注册、执行、撤销、重做领域命令
+   */
+  c;
+  /**
+   * @description 向领域依赖注入容器中注册一个或多个领域服务
+   * @param service 单个领域服务类或数组
+   * @param options 领域服务注册配置项，可传入领域服务构造参数以及配置依赖解决拦截器和频率等
+   * @example
+   * ```typescript
+   * class ServiceOne extends DomainService {
+   *
+   *   // before resolve 拦截器
+   *   public static beforeResolution(token: InjectionToken, resolutionType: string) {}
+   *
+   *   // after resolve 拦截器
+   *   public static afterResolution(token: InjectionToken, result: ServiceOne | ServiceOne[], resolutionType: string) {}
+   *
+   *   constructor(public arg: string, public arg2: number) {
+   *     super();
+   *   }
+   * }
+   *
+   * // 注册领域服务
+   * domain.registerService(ServiceOne, { beforeResolution: ServiceOne.beforeResolution, afterResolution: ServiceOne.afterResolution })
+   * ```
+   */
+  registerService(e, t) {
+    const s = Array.isArray(e) ? e : [e], i = t ? Array.isArray(t) ? t : [t] : [];
+    for (let o = 0; o < s.length; o += 1) {
+      const r = s[o], a = i[o];
+      if (this.dic.isRegistered(r.name) || this.dic.isRegistered(r)) {
+        console.warn(`服务 ${r.name} 已注册，跳过注册`);
+        continue;
+      }
+      this.dic.register(r.name, { useClass: r }), this.dic.register(r, { useClass: r }), a?.beforeResolution && (this.dic.beforeResolution(r.name, a.beforeResolution, {
+        frequency: a?.beforeResolutionFrequency || "Always"
+      }), this.dic.beforeResolution(r, a.beforeResolution, {
+        frequency: a?.beforeResolutionFrequency || "Always"
+      })), a?.afterResolution && (this.dic.afterResolution(r.name, a.afterResolution, {
+        frequency: a?.afterResolutionFrequency || "Always"
+      }), this.dic.afterResolution(r, a?.afterResolution, {
+        frequency: a?.afterResolutionFrequency || "Always"
+      }));
+    }
+  }
+  /**
+   * @description 向领域依赖注入容器中注册领域实体，指定缓存策略为'cache'时全局单例。
+   * @param entity 单个领域实体类或数组
+   * @param options 领域实体注册配置项
+   * @example
+   * ```typescript
+   * class EntityOne extends DomainEntity {
+   *
+   *   // before resolve 拦截器
+   *   public static beforeResolution(token: InjectionToken, resolutionType: string) {}
+   *
+   *   // after resolve 拦截器
+   *   public static afterResolution(token: InjectionToken, result: EntityOne | EntityOne[], resolutionType: string) {}
+   *
+   *   constructor(public arg: string, public arg2: number) {
+   *     super();
+   *   }
+   * }
+   *
+   * // 注册领域实体
+   * domain.registerEntity(EntityOne, { cachePolicy: 'cache', beforeResolution: EntityOne.beforeResolution, afterResolution: EntityOne.afterResolution })
+   * ```
+   */
+  registerEntity(e, t) {
+    const s = Array.isArray(e) ? e : [e], i = t ? Array.isArray(t) ? t : [t] : [];
+    for (let o = 0; o < s.length; o += 1) {
+      const r = s[o], a = i[o];
+      if (this.dic.isRegistered(r.name) || this.dic.isRegistered(r)) {
+        console.warn(`实体 ${r.name} 已注册，跳过注册`);
+        continue;
+      }
+      if (a?.cachePolicy)
+        switch (a.cachePolicy) {
+          case "cache":
+            l.register(r.name, { useClass: r }, { lifecycle: c.Singleton }), l.register(r, { useClass: r }, { lifecycle: c.Singleton });
+            break;
+          case "containerCache":
+            this.dic.register(r.name, { useClass: r }, { lifecycle: c.ContainerScoped }), this.dic.register(r, { useClass: r }, { lifecycle: c.ContainerScoped });
+            break;
+          case "resolution":
+            this.dic.register(r.name, { useClass: r }, { lifecycle: c.ResolutionScoped }), this.dic.register(r, { useClass: r }, { lifecycle: c.ResolutionScoped });
+            break;
+        }
+      else
+        this.dic.register(r.name, { useClass: r }, { lifecycle: c.Transient }), this.dic.register(r, { useClass: r }, { lifecycle: c.Transient });
+      a?.beforeResolution && (this.dic.beforeResolution(r.name, a.beforeResolution, {
+        frequency: a?.beforeResolutionFrequency || "Always"
+      }), this.dic.beforeResolution(r, a.beforeResolution, {
+        frequency: a?.beforeResolutionFrequency || "Always"
+      })), a?.afterResolution && (this.dic.afterResolution(r.name, a.afterResolution, {
+        frequency: a?.afterResolutionFrequency || "Always"
+      }), this.dic.afterResolution(r, a.afterResolution, {
+        frequency: a?.afterResolutionFrequency || "Always"
+      }));
+    }
+  }
+  /**
+   * @summary 项领域内依赖注入容器中注册值对象，当指定 factoryType 为'cache'时全局单例。
+   * @description 需要泛型类型 V，约束工厂函数返回类型，V 满足 VO 类型约束，不允许包含函数属性
+   * @param vos 值对象注册配置项
+   * @example
+   * ```typescript
+   * domain.registerVO({
+   *   token: 'VO1',
+   *   factoryType: 'cache',
+   *   resolveFactory: () => ({ date: '2023-01-01' })
+   * })
+   * ```
+   */
+  registerVO(e) {
+    const t = Array.isArray(e) ? e : [e];
+    for (let s = 0; s < t.length; s += 1) {
+      const i = t[s], o = Array.isArray(i.token) ? i.token : [i.token];
+      for (let r = 0; r < o.length; r += 1) {
+        const a = o[r];
+        switch (i.factoryType) {
+          case "cache":
+            l.register(a, { useFactory: p(i.resolveFactory) });
+            break;
+          case "containerCache":
+            this.dic.register(a, { useFactory: g(i.resolveFactory) });
+            break;
+          case "predicate":
+            this.dic.register(a, {
+              useFactory: m(
+                i.resolveFactory,
+                i.positiveTarget,
+                i.negativeTarget
+              )
+            });
+            break;
+          default:
+            this.dic.register(a, { useFactory: i.resolveFactory });
+            break;
+        }
+      }
+    }
+  }
+  /**
+   * @description 从依赖注入容器中获取领域服务实例对象
+   * @param token 领域服务token
+   * @returns 领域服务实例对象
+   */
+  services(e) {
+    const t = this.dic.resolve(e);
+    return t && !t?.e && (t.e = this.e), t;
+  }
+  /**
+   * @description 从依赖注入容器中获取领域实体实例对象
+   * @param sourceToken 源领域实体token，存在适配器时是 DEF 泛型类型，否则为 DE 泛型类型
+   * @param adapter 领域实体适配器，将 DEF 类型转换为 DE 类型
+   * @returns 领域实体实例对象
+   */
+  entities(e, t) {
+    let s;
+    if (t) {
+      const i = this.dic.resolve(e);
+      s = t.transform(i);
+    } else
+      s = this.dic.resolve(e);
+    return s && !s?.e && (s.e = this.e), s;
+  }
+  /**
+   * @description 从依赖注入容器中获取领域值对象实例对象
+   * @param sourceToken 源领域值对象token，存在适配器时是 VF 泛型类型，否则为 V 泛型类型
+   * @param adapter 领域值对象适配器，将 VF 类型转换为 V 类型
+   * @returns 领域值对象实例对象
+   */
+  vos(e, t) {
+    if (t) {
+      const s = this.dic.resolve(e);
+      return t.transform(s);
+    } else
+      return this.dic.resolve(e);
+  }
+  /**
+   * 域基类构造函数
+   */
+  constructor(e) {
+    this.c = new f(e);
+  }
+}
+const d = (n) => (n.prototype.$ins = null, class extends n {
+  constructor(...e) {
+    return super(...e), n.prototype.$ins || (n.prototype.$ins = this), n.prototype.$ins;
+  }
+});
+var x = Object.getOwnPropertyDescriptor, w = (n, e, t, s) => {
+  for (var i = s > 1 ? void 0 : s ? x(e, t) : e, o = n.length - 1, r; o >= 0; o--)
+    (r = n[o]) && (i = r(i) || i);
   return i;
 };
 let h = class {
+  /** 事件句柄 */
+  e = void 0;
+  /**
+   * 域基类构造函数
+   */
+  constructor() {
+  }
+};
+h = w([
+  d
+], h);
+class I {
+  /** 事件句柄 */
+  e = void 0;
+  /**
+   * 域基类构造函数
+   */
+  constructor() {
+  }
+}
+var A = Object.getOwnPropertyDescriptor, F = (n, e, t, s) => {
+  for (var i = s > 1 ? void 0 : s ? A(e, t) : e, o = n.length - 1, r; o >= 0; o--)
+    (r = n[o]) && (i = r(i) || i);
+  return i;
+};
+let y = class {
   /** 全局 DIC */
   globalDIC = l;
   /** 命令系统 */
@@ -531,71 +655,68 @@ let h = class {
   /**
    * 注册领域对象
    */
-  registerDomain(o, e) {
-    const s = Array.isArray(o) ? o : [o], r = e ? Array.isArray(e) ? e : [e] : [];
-    for (let i = 0; i < s.length; i += 1) {
-      const n = s[i], t = r[i];
-      if (this.globalDIC.isRegistered(n.name)) {
-        console.warn(`领域 ${n.name} 已注册，无法重复注册`);
+  registerDomain(n, e) {
+    const t = Array.isArray(n) ? n : [n], s = e ? Array.isArray(e) ? e : [e] : [];
+    for (let i = 0; i < t.length; i += 1) {
+      const o = t[i], r = s[i];
+      if (this.globalDIC.isRegistered(o.name)) {
+        console.warn(`领域 ${o.name} 已注册，无法重复注册`);
         return;
       }
-      const c = new n(...t?.args || []);
-      this.globalDIC.register(n.name, { useValue: c }), this.globalDIC.register(n, { useValue: c }), t?.beforeResolution && (this.globalDIC.beforeResolution(n.name, t.beforeResolution, {
-        frequency: t.beforeResolutionFrequency || "Always"
-      }), this.globalDIC.beforeResolution(n, t.beforeResolution, {
-        frequency: t.afterResolutionFrequency || "Always"
-      })), t?.afterResolution && (this.globalDIC.afterResolution(n.name, t.afterResolution, {
-        frequency: t.afterResolutionFrequency || "Always"
-      }), this.globalDIC.afterResolution(n, t.afterResolution, {
-        frequency: t.afterResolutionFrequency || "Always"
+      const a = new o(...r?.args || []);
+      this.globalDIC.register(o.name, { useValue: a }), this.globalDIC.register(o, { useValue: a }), r?.beforeResolution && (this.globalDIC.beforeResolution(o.name, r.beforeResolution, {
+        frequency: r.beforeResolutionFrequency || "Always"
+      }), this.globalDIC.beforeResolution(o, r.beforeResolution, {
+        frequency: r.afterResolutionFrequency || "Always"
+      })), r?.afterResolution && (this.globalDIC.afterResolution(o.name, r.afterResolution, {
+        frequency: r.afterResolutionFrequency || "Always"
+      }), this.globalDIC.afterResolution(o, r.afterResolution, {
+        frequency: r.afterResolutionFrequency || "Always"
       }));
     }
   }
   /**
    * 获取领域对象
    */
-  domains(o) {
-    return this.globalDIC.resolve(o);
+  domains(n) {
+    return this.globalDIC.resolve(n);
   }
   /**
    * 提供全局的转换方法
    */
-  transform(o, e) {
-    return e.transform(o);
+  transform(n, e) {
+    return e.transform(n);
   }
   /**
    * 提供全局的转换方法，支持批量转换
    */
-  transformAll(o, e) {
-    const s = [];
-    for (let r = 0; r < o.length; r += 1) {
-      const i = e.transform(o[r]);
-      i != null && s.push(i);
+  transformAll(n, e) {
+    const t = [];
+    for (let s = 0; s < n.length; s += 1) {
+      const i = e.transform(n[s]);
+      i != null && t.push(i);
     }
-    return s;
+    return t;
   }
   /**
    * 构造函数
    * @param option 配置参数
    */
-  constructor(o) {
-    this.c = new D({
-      maxHistoryDepth: o?.maxHistoryDepth,
-      maxUndoHistoryDepth: o?.maxUndoHistoryDepth
+  constructor(n) {
+    this.c = new f({
+      maxHistoryDepth: n?.maxHistoryDepth,
+      maxUndoHistoryDepth: n?.maxUndoHistoryDepth
     });
   }
 };
-h = x([
-  y
-], h);
+y = F([
+  d
+], y);
 export {
-  _ as Adapter,
-  R as CommandInvoker,
-  D as CommandSystem,
-  C as ConcreteCommand,
-  w as Domain,
-  F as DomainEntity,
-  u as DomainService,
-  h as GDMB,
-  H as createCommand
+  q as Adapter,
+  f as CommandSystem,
+  k as Domain,
+  I as DomainEntity,
+  h as DomainService,
+  y as GDMB
 };

package/dist/gdmb.umd.js

@@ -1 +1 @@
-(function(l,a){typeof exports=="object"&&typeof module<"u"?a(exports,require("tsyringe")):typeof define=="function"&&define.amd?define(["exports","tsyringe"],a):(l=typeof globalThis<"u"?globalThis:l||self,a(l.gdmb={},l.tsyringe))})(this,(function(l,a){"use strict";class g{_mapper={};register(e){e in this._mapper||(this._mapper[e]=[])}remove(e){e in this._mapper&&delete this._mapper[e]}on(e,s){const i=this._mapper[e];i?i.push(s):(this.register(e),this.on(e,s))}off(e,s){const i=this._mapper[e];if(i){const r=i.indexOf(s);r!==-1&&i.splice(r,1)}}trigger(e,...s){const i=this._mapper[e];i&&setTimeout(()=>{for(const r of Object.values(i))r(...s)},0)}constructor(){}}class p{}class v{dic=a.container.createChildContainer();e=new g;registerService(e,s){const i=Array.isArray(e)?e:[e],r=s?Array.isArray(s)?s:[s]:[];for(let n=0;n<i.length;n+=1){const t=i[n],o=r[n];if(this.dic.isRegistered(t.name)||this.dic.isRegistered(t)){console.warn(`服务 ${t.name} 已注册，跳过注册`);continue}this.dic.register(t.name,{useClass:t}),this.dic.register(t,{useClass:t}),o?.beforeResolution&&(this.dic.beforeResolution(t.name,o.beforeResolution,{frequency:o?.beforeResolutionFrequency||"Always"}),this.dic.beforeResolution(t,o.beforeResolution,{frequency:o?.beforeResolutionFrequency||"Always"})),o?.afterResolution&&(this.dic.afterResolution(t.name,o.afterResolution,{frequency:o?.afterResolutionFrequency||"Always"}),this.dic.afterResolution(t,o?.afterResolution,{frequency:o?.afterResolutionFrequency||"Always"}))}}registerEntity(e,s){const i=Array.isArray(e)?e:[e],r=s?Array.isArray(s)?s:[s]:[];for(let n=0;n<i.length;n+=1){const t=i[n],o=r[n];if(this.dic.isRegistered(t.name)||this.dic.isRegistered(t)){console.warn(`实体 ${t.name} 已注册，跳过注册`);continue}if(o?.cachePolicy)switch(o.cachePolicy){case"cache":a.container.register(t.name,{useClass:t},{lifecycle:a.Lifecycle.Singleton}),a.container.register(t,{useClass:t},{lifecycle:a.Lifecycle.Singleton});break;case"containerCache":this.dic.register(t.name,{useClass:t},{lifecycle:a.Lifecycle.ContainerScoped}),this.dic.register(t,{useClass:t},{lifecycle:a.Lifecycle.ContainerScoped});break;case"resolution":this.dic.register(t.name,{useClass:t},{lifecycle:a.Lifecycle.ResolutionScoped}),this.dic.register(t,{useClass:t},{lifecycle:a.Lifecycle.ResolutionScoped});break}else this.dic.register(t.name,{useClass:t},{lifecycle:a.Lifecycle.Transient}),this.dic.register(t,{useClass:t},{lifecycle:a.Lifecycle.Transient});o?.beforeResolution&&(this.dic.beforeResolution(t.name,o.beforeResolution,{frequency:"Always"}),this.dic.beforeResolution(t,o.beforeResolution,{frequency:"Always"})),o?.afterResolution&&(this.dic.afterResolution(t.name,o.afterResolution,{frequency:"Always"}),this.dic.afterResolution(t,o.afterResolution,{frequency:"Always"}))}}registerVO(e){const s=Array.isArray(e)?e:[e];for(let i=0;i<s.length;i+=1){const r=s[i],n=Array.isArray(r.token)?r.token:[r.token];for(let t=0;t<n.length;t+=1){const o=n[t];switch(r.factoryType){case"cache":a.container.register(o,{useFactory:a.instanceCachingFactory(r.resolveFactory)});break;case"containerCache":this.dic.register(o,{useFactory:a.instancePerContainerCachingFactory(r.resolveFactory)});break;case"predicate":this.dic.register(o,{useFactory:a.predicateAwareClassFactory(r.resolveFactory,r.positiveTarget,r.negativeTarget)});break;default:this.dic.register(o,{useFactory:r.resolveFactory});break}}}}services(e){const s=this.dic.resolve(e);return s&&!s?.e&&(s.e=this.e),s}entities(e,s){let i;if(s){const r=this.dic.resolve(e);i=s.transform(r)}else i=this.dic.resolve(e);return i&&!i?.e&&(i.e=this.e),i}vos(e,s){if(s){const i=this.dic.resolve(e);return s.transform(i)}else return this.dic.resolve(e)}constructor(){}}const u=c=>(c.prototype.$ins=null,class extends c{constructor(...e){return super(...e),c.prototype.$ins||(c.prototype.$ins=this),c.prototype.$ins}});var C=Object.getOwnPropertyDescriptor,D=(c,e,s,i)=>{for(var r=i>1?void 0:i?C(e,s):e,n=c.length-1,t;n>=0;n--)(t=c[n])&&(r=t(r)||r);return r};l.DomainService=class{e=void 0;constructor(){}},l.DomainService=D([u],l.DomainService);class R{e=void 0;constructor(){}}class h{history=[];undoHistory=[];maxHistoryDepth;maxUndoHistoryDepth;execute(e){e.execute(),this.history.push({command:e,timestamp:Date.now()}),this.undoHistory=[],this.history.length>this.maxHistoryDepth&&this.history.shift()}undo(){if(this.history.length===0)return!1;const e=this.history.pop();return e?(e.command.undo(),this.undoHistory.push(e),this.undoHistory.length>this.maxUndoHistoryDepth&&this.undoHistory.shift(),!0):!1}redo(){if(this.undoHistory.length===0)return!1;const e=this.undoHistory.pop();return e?(e.command.execute(),this.history.push(e),this.history.length>this.maxHistoryDepth&&this.history.shift(),!0):!1}executeBatch(e){e.forEach(s=>this.execute(s))}clearHistory(){this.history=[],this.undoHistory=[]}getHistory(){return[...this.history]}getUndoHistory(){return[...this.undoHistory]}getHistoryCount(){return this.history.length}getUndoHistoryCount(){return this.undoHistory.length}constructor(e){this.maxHistoryDepth=e?.maxHistoryDepth||1/0,this.maxUndoHistoryDepth=e?.maxUndoHistoryDepth||1/0}}class f{receiver;executeFn;undoFn;description;constructor(e,s,i,r){this.receiver=e,this.executeFn=s,this.undoFn=i,this.description=r}execute(){this.executeFn(this.receiver)}undo(){this.undoFn(this.receiver)}getDescription(){return this.description}}function y(c,e,s,i){return new f(c,e,s,i)}class d{invoker;create(e,s,i,r){return y(e,s,i,r)}execute(e){this.invoker.execute(e)}undo(){return this.invoker.undo()}redo(){return this.invoker.redo()}executeBatch(e){this.invoker.executeBatch(e)}clearHistory(){this.invoker.clearHistory()}getHistory(){return this.invoker.getHistory()}getUndoHistory(){return this.invoker.getUndoHistory()}getHistoryCount(){return this.invoker.getHistoryCount()}getUndoHistoryCount(){return this.invoker.getUndoHistoryCount()}constructor(e){this.invoker=new h({maxHistoryDepth:e?.maxHistoryDepth,maxUndoHistoryDepth:e?.maxUndoHistoryDepth})}}var H=Object.getOwnPropertyDescriptor,b=(c,e,s,i)=>{for(var r=i>1?void 0:i?H(e,s):e,n=c.length-1,t;n>=0;n--)(t=c[n])&&(r=t(r)||r);return r};l.GDMB=class{globalDIC=a.container;c;registerDomain(e,s){const i=Array.isArray(e)?e:[e],r=s?Array.isArray(s)?s:[s]:[];for(let n=0;n<i.length;n+=1){const t=i[n],o=r[n];if(this.globalDIC.isRegistered(t.name)){console.warn(`领域 ${t.name} 已注册，无法重复注册`);return}const m=new t(...o?.args||[]);this.globalDIC.register(t.name,{useValue:m}),this.globalDIC.register(t,{useValue:m}),o?.beforeResolution&&(this.globalDIC.beforeResolution(t.name,o.beforeResolution,{frequency:o.beforeResolutionFrequency||"Always"}),this.globalDIC.beforeResolution(t,o.beforeResolution,{frequency:o.afterResolutionFrequency||"Always"})),o?.afterResolution&&(this.globalDIC.afterResolution(t.name,o.afterResolution,{frequency:o.afterResolutionFrequency||"Always"}),this.globalDIC.afterResolution(t,o.afterResolution,{frequency:o.afterResolutionFrequency||"Always"}))}}domains(e){return this.globalDIC.resolve(e)}transform(e,s){return s.transform(e)}transformAll(e,s){const i=[];for(let r=0;r<e.length;r+=1){const n=s.transform(e[r]);n!=null&&i.push(n)}return i}constructor(e){this.c=new d({maxHistoryDepth:e?.maxHistoryDepth,maxUndoHistoryDepth:e?.maxUndoHistoryDepth})}},l.GDMB=b([u],l.GDMB),l.Adapter=p,l.CommandInvoker=h,l.CommandSystem=d,l.ConcreteCommand=f,l.Domain=v,l.DomainEntity=R,l.createCommand=y,Object.defineProperty(l,Symbol.toStringTag,{value:"Module"})}));
+(function(l,a){typeof exports=="object"&&typeof module<"u"?a(exports,require("tsyringe")):typeof define=="function"&&define.amd?define(["exports","tsyringe"],a):(l=typeof globalThis<"u"?globalThis:l||self,a(l.gdmb={},l.tsyringe))})(this,(function(l,a){"use strict";class y{_mapper={};register(e){e in this._mapper||(this._mapper[e]=[])}remove(e){e in this._mapper&&delete this._mapper[e]}on(e,t){const s=this._mapper[e];s?s.push(t):(this.register(e),this.on(e,t))}off(e,t){const s=this._mapper[e];if(s){const i=s.indexOf(t);i!==-1&&s.splice(i,1)}}trigger(e,...t){const s=this._mapper[e];s&&setTimeout(()=>{for(const i of Object.values(s))i(...t)},0)}constructor(){}}class d{}class m{history=[];undoHistory=[];maxHistoryDepth;maxUndoHistoryDepth;execute(e,t=!0){e.execute(),t&&(this.history.push({command:e,timestamp:Date.now()}),this.undoHistory=[],this.history.length>this.maxHistoryDepth&&this.history.shift())}undo(){if(this.history.length===0)return!1;const e=this.history.pop();return e?(e.command.undo(),this.undoHistory.push(e),this.undoHistory.length>this.maxUndoHistoryDepth&&this.undoHistory.shift(),!0):!1}redo(){if(this.undoHistory.length===0)return!1;const e=this.undoHistory.pop();return e?(e.command.execute(),this.history.push(e),this.history.length>this.maxHistoryDepth&&this.history.shift(),!0):!1}executeBatch(e,t=!0){e.forEach(s=>this.execute(s,t))}clearHistory(){this.history=[],this.undoHistory=[]}getHistory(){return[...this.history]}getUndoHistory(){return[...this.undoHistory]}getHistoryCount(){return this.history.length}getUndoHistoryCount(){return this.undoHistory.length}constructor(e){this.maxHistoryDepth=e?.maxHistoryDepth||30,this.maxUndoHistoryDepth=e?.maxUndoHistoryDepth||30}}class g{receiver;executeFn;undoFn;description;commandString;constructor(e,t,s,i,n=""){this.receiver=e,this.executeFn=t,this.undoFn=s,this.description=i,this.commandString=n}execute(){this.executeFn(this.receiver)}undo(){this.undoFn(this.receiver)}getDescription(){return this.description}getCommandString(){return this.commandString}}function p(c,e,t,s,i=""){return new g(c,e,t,s,i)}class C{commands=new Map;register(e,t,s){this.commands.set(e,{receiver:t,description:s})}get(e){return this.commands.get(e)}listCommands(){return[...this.commands.entries()].map(([e,t])=>({name:e,description:t.description}))}}class v{parse(e){const t=e.trim().split(/\s+/g),s=t[0],i=new Map;for(let n=1;n<t.length;n++){const r=t[n];if(r.startsWith("-")){const o=r.slice(1);if(n+1>=t.length||t[n+1].startsWith("-"))i.set(o,!0);else{const u=t[n+1];isNaN(Number(u))?i.set(o,u):i.set(o,Number(u)),n++}}}return{commandName:s,options:i,args:t.slice(1)}}}class h{invoker;parser=new v;registry=new C;register(e){this.registry.register(e.name,e,e.description)}create(e,t,s,i,n=""){return p(e,t,s,i,n)}createFromCommandString(e,t){const s=this.parser.parse(e),i=this.registry.get(s.commandName);if(!i){console.warn(`命令 ${s.commandName} 未注册`);return}return i.receiver.creator?.(s.options,s.args,t||i.description,e)}execute(e,t,s=!0){if(typeof e=="string"){const i=this.createFromCommandString(e,t);i&&this.invoker.execute(i,s)}else this.invoker.execute(e,s)}undo(){return this.invoker.undo()}redo(){return this.invoker.redo()}executeBatch(e,t=!0){this.invoker.executeBatch(e,t)}clearHistory(){this.invoker.clearHistory()}getHistory(){return this.invoker.getHistory()}getUndoHistory(){return this.invoker.getUndoHistory()}getHistoryCount(){return this.invoker.getHistoryCount()}getUndoHistoryCount(){return this.invoker.getUndoHistoryCount()}listCommands(){return this.registry.listCommands()}constructor(e){this.invoker=new m({maxHistoryDepth:e?.maxHistoryDepth,maxUndoHistoryDepth:e?.maxUndoHistoryDepth})}}class R{dic=a.container.createChildContainer();e=new y;c;registerService(e,t){const s=Array.isArray(e)?e:[e],i=t?Array.isArray(t)?t:[t]:[];for(let n=0;n<s.length;n+=1){const r=s[n],o=i[n];if(this.dic.isRegistered(r.name)||this.dic.isRegistered(r)){console.warn(`服务 ${r.name} 已注册，跳过注册`);continue}this.dic.register(r.name,{useClass:r}),this.dic.register(r,{useClass:r}),o?.beforeResolution&&(this.dic.beforeResolution(r.name,o.beforeResolution,{frequency:o?.beforeResolutionFrequency||"Always"}),this.dic.beforeResolution(r,o.beforeResolution,{frequency:o?.beforeResolutionFrequency||"Always"})),o?.afterResolution&&(this.dic.afterResolution(r.name,o.afterResolution,{frequency:o?.afterResolutionFrequency||"Always"}),this.dic.afterResolution(r,o?.afterResolution,{frequency:o?.afterResolutionFrequency||"Always"}))}}registerEntity(e,t){const s=Array.isArray(e)?e:[e],i=t?Array.isArray(t)?t:[t]:[];for(let n=0;n<s.length;n+=1){const r=s[n],o=i[n];if(this.dic.isRegistered(r.name)||this.dic.isRegistered(r)){console.warn(`实体 ${r.name} 已注册，跳过注册`);continue}if(o?.cachePolicy)switch(o.cachePolicy){case"cache":a.container.register(r.name,{useClass:r},{lifecycle:a.Lifecycle.Singleton}),a.container.register(r,{useClass:r},{lifecycle:a.Lifecycle.Singleton});break;case"containerCache":this.dic.register(r.name,{useClass:r},{lifecycle:a.Lifecycle.ContainerScoped}),this.dic.register(r,{useClass:r},{lifecycle:a.Lifecycle.ContainerScoped});break;case"resolution":this.dic.register(r.name,{useClass:r},{lifecycle:a.Lifecycle.ResolutionScoped}),this.dic.register(r,{useClass:r},{lifecycle:a.Lifecycle.ResolutionScoped});break}else this.dic.register(r.name,{useClass:r},{lifecycle:a.Lifecycle.Transient}),this.dic.register(r,{useClass:r},{lifecycle:a.Lifecycle.Transient});o?.beforeResolution&&(this.dic.beforeResolution(r.name,o.beforeResolution,{frequency:o?.beforeResolutionFrequency||"Always"}),this.dic.beforeResolution(r,o.beforeResolution,{frequency:o?.beforeResolutionFrequency||"Always"})),o?.afterResolution&&(this.dic.afterResolution(r.name,o.afterResolution,{frequency:o?.afterResolutionFrequency||"Always"}),this.dic.afterResolution(r,o.afterResolution,{frequency:o?.afterResolutionFrequency||"Always"}))}}registerVO(e){const t=Array.isArray(e)?e:[e];for(let s=0;s<t.length;s+=1){const i=t[s],n=Array.isArray(i.token)?i.token:[i.token];for(let r=0;r<n.length;r+=1){const o=n[r];switch(i.factoryType){case"cache":a.container.register(o,{useFactory:a.instanceCachingFactory(i.resolveFactory)});break;case"containerCache":this.dic.register(o,{useFactory:a.instancePerContainerCachingFactory(i.resolveFactory)});break;case"predicate":this.dic.register(o,{useFactory:a.predicateAwareClassFactory(i.resolveFactory,i.positiveTarget,i.negativeTarget)});break;default:this.dic.register(o,{useFactory:i.resolveFactory});break}}}}services(e){const t=this.dic.resolve(e);return t&&!t?.e&&(t.e=this.e),t}entities(e,t){let s;if(t){const i=this.dic.resolve(e);s=t.transform(i)}else s=this.dic.resolve(e);return s&&!s?.e&&(s.e=this.e),s}vos(e,t){if(t){const s=this.dic.resolve(e);return t.transform(s)}else return this.dic.resolve(e)}constructor(e){this.c=new h(e)}}const f=c=>(c.prototype.$ins=null,class extends c{constructor(...e){return super(...e),c.prototype.$ins||(c.prototype.$ins=this),c.prototype.$ins}});var D=Object.getOwnPropertyDescriptor,b=(c,e,t,s)=>{for(var i=s>1?void 0:s?D(e,t):e,n=c.length-1,r;n>=0;n--)(r=c[n])&&(i=r(i)||i);return i};l.DomainService=class{e=void 0;constructor(){}},l.DomainService=b([f],l.DomainService);class H{e=void 0;constructor(){}}var w=Object.getOwnPropertyDescriptor,A=(c,e,t,s)=>{for(var i=s>1?void 0:s?w(e,t):e,n=c.length-1,r;n>=0;n--)(r=c[n])&&(i=r(i)||i);return i};l.GDMB=class{globalDIC=a.container;c;registerDomain(e,t){const s=Array.isArray(e)?e:[e],i=t?Array.isArray(t)?t:[t]:[];for(let n=0;n<s.length;n+=1){const r=s[n],o=i[n];if(this.globalDIC.isRegistered(r.name)){console.warn(`领域 ${r.name} 已注册，无法重复注册`);return}const u=new r(...o?.args||[]);this.globalDIC.register(r.name,{useValue:u}),this.globalDIC.register(r,{useValue:u}),o?.beforeResolution&&(this.globalDIC.beforeResolution(r.name,o.beforeResolution,{frequency:o.beforeResolutionFrequency||"Always"}),this.globalDIC.beforeResolution(r,o.beforeResolution,{frequency:o.afterResolutionFrequency||"Always"})),o?.afterResolution&&(this.globalDIC.afterResolution(r.name,o.afterResolution,{frequency:o.afterResolutionFrequency||"Always"}),this.globalDIC.afterResolution(r,o.afterResolution,{frequency:o.afterResolutionFrequency||"Always"}))}}domains(e){return this.globalDIC.resolve(e)}transform(e,t){return t.transform(e)}transformAll(e,t){const s=[];for(let i=0;i<e.length;i+=1){const n=t.transform(e[i]);n!=null&&s.push(n)}return s}constructor(e){this.c=new h({maxHistoryDepth:e?.maxHistoryDepth,maxUndoHistoryDepth:e?.maxUndoHistoryDepth})}},l.GDMB=A([f],l.GDMB),l.Adapter=d,l.CommandSystem=h,l.Domain=R,l.DomainEntity=H,Object.defineProperty(l,Symbol.toStringTag,{value:"Module"})}));

package/dist/skills/gdmb/SKILL.md

@@ -155,11 +155,35 @@ const voOne = domainObject.vos<IVOOne>('IVOOne'); // { text: 'text', num: 1 }
 ### 命令系统（Command System）
 ```typescript
 import { GDMB } from 'gdmb';
-import type { Command, CommandReceiver } from 'gdmb';
+import type { Command, CommandReceiver, CommandCreator } from 'gdmb';
 // 实例化全局对象
 const gdmb = new GDMB();
 // 定义命令接受者作为命令执行者
 class CounterReceiver implements CounterReceiver {
+  // 命令名称，用于命令注册和执行（必要）
+  name: 'counter';
+  // 命令描述，说明命令作用和支持的参数
+  description: `
+  计算器命令，支持参数：
+  -type increment | decrement
+  -value number
+  `;
+  // 命令创建器，返回一个Command对象（必要）
+  creator: CommandCreator = (
+    options: Map<string, string | number | boolean>,
+    args: string[],
+    description: string,
+    commandString: string
+  ) => {
+    const value = (options.get('value') as number) || 0;
+    return gdmb.c.create(
+      this,
+      (r) => r.executeOperation(value),
+      (r) => r.undoOperation(),
+      description,
+      commandString
+    );
+  };
   // 执行函数（必要）
   executeOperation({ type, value = 1 }: { type: string; value?: number }): void {
     // 执行函数实现
@@ -178,6 +202,10 @@ const command = gdmb.c.create(
 );
 // 执行命令
 gdmb.c.execute(command);
+// 撤销命令
+gdmb.c.undo(command);
+// 执行字符串命令
+gdmb.c.execute('counter -type increment -value 5');
 ```
 
 ## 代码检查清单（Code Review Checklist）

package/dist/src/command/Command.d.ts

@@ -15,6 +15,29 @@ export interface Command {
      * 获取命令描述
      */
     getDescription(): string;
+    /**
+     * 获取原始命令字符串
+     */
+    getCommandString(): string;
+}
+/**
+ * 解析后的命令参数
+ */
+export interface ParsedCommand {
+    commandName: string;
+    options: Map<string, string | number | boolean>;
+    args: string[];
+}
+/**
+ * 命令创建函数类型
+ */
+export type CommandCreator = (options: Map<string, string | number | boolean>, args: string[], description: string, commandString: string) => Command;
+/**
+ * 命令注册项
+ */
+export interface CommandRegistration<R extends CommandReceiver> {
+    receiver: R;
+    description: string;
 }
 /**
  * 命令历史记录项
@@ -28,6 +51,12 @@ export interface CommandHistoryItem {
  * 定义命令接收者的标准接口
  */
 export interface CommandReceiver {
+    /** 命名名称 */
+    name: string;
+    /** 命令描述 */
+    description: string;
+    /** 创建器 */
+    creator?: CommandCreator;
     /**
      * 执行命令操作
      * @param args 命令参数

package/dist/src/command/CommandInvoker.d.ts

@@ -19,8 +19,9 @@ export declare class CommandInvoker {
     /**
      * 执行命令
      * @param command 要执行的命令
+     * @param pushToHistory 是否将命令推入历史记录，默认为 true
      */
-    execute(command: Command): void;
+    execute(command: Command, pushToHistory?: boolean): void;
     /**
      * 撤销上一个命令
      * @returns 是否成功撤销
@@ -34,8 +35,9 @@ export declare class CommandInvoker {
     /**
      * 批量执行命令
      * @param commands 要执行的命令数组
+     * @param pushToHistory 是否将命令推入历史记录，默认为 true
      */
-    executeBatch(commands: Command[]): void;
+    executeBatch(commands: Command[], pushToHistory?: boolean): void;
     /**
      * 清空命令历史
      */

package/dist/src/command/CommandParser.d.ts

@@ -0,0 +1,12 @@
+import { ParsedCommand } from './Command';
+/**
+ * 命令解析器
+ */
+export declare class CommandParser {
+    /**
+     * 解析命令字符串
+     * @param commandString 命令字符串，如 "add -a 10 -b 5"
+     * @returns ParsedCommand 对象
+     */
+    parse(commandString: string): ParsedCommand;
+}

package/dist/src/command/CommandRegistry.d.ts

@@ -0,0 +1,27 @@
+import { CommandRegistration, CommandReceiver } from './Command';
+/**
+ * 命令注册器
+ */
+export declare class CommandRegistry<R extends CommandReceiver> {
+    /** 命令注册映射 */
+    private commands;
+    /**
+     * 注册命令
+     * @param name 命令名
+     * @param receiver 命令接收者
+     * @param creator 命令创建函数
+     * @param description 命令描述
+     */
+    register(name: string, receiver: R, description: string): void;
+    /**
+     * 获取命令注册信息
+     */
+    get(name: string): CommandRegistration<R> | undefined;
+    /**
+     * 列出所有已注册的命令
+     */
+    listCommands(): Array<{
+        name: string;
+        description: string;
+    }>;
+}

package/dist/src/command/CommandSystem.d.ts

@@ -4,20 +4,44 @@ export declare class CommandSystem {
      * 命令调用者
      */
     private invoker;
+    /**
+     * 命令解析器
+     */
+    private parser;
+    /**
+     * 命令注册器
+     */
+    private registry;
+    /**
+     * 注册命令
+     * @param name 命令名称
+     * @param receiver 命令接收者
+     */
+    register<R extends CommandReceiver>(receiver: R): void;
     /**
      * 创建命令
      * @param receiver 命令接收者
      * @param executeFn 执行操作的函数
      * @param undoFn 撤销操作的函数
      * @param description 命令描述
+     * @param commandString 原始命令字符串
      * @returns 命令对象
      */
-    create<R extends CommandReceiver>(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string): Command;
+    create<R extends CommandReceiver>(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string, commandString?: string): Command;
+    /**
+     * 从命令字符串创建 Command
+     * @param commandString 命令字符串
+     * @param description 针对本次命令描述
+     * @returns Command 实例，失败返回 undefined
+     */
+    createFromCommandString(commandString: string, description?: string): Command | undefined;
     /**
      * 执行命令
      * @param command 要执行的命令
+     * @param description 针对本次命令描述
+     * @param pushToHistory 是否将命令推入历史记录，默认为 true
      */
-    execute(command: Command): void;
+    execute(command: Command | string, description?: string, pushToHistory?: boolean): void;
     /**
      * 撤销上一个命令
      * @returns 是否成功撤销
@@ -31,8 +55,9 @@ export declare class CommandSystem {
     /**
      * 批量执行命令
      * @param commands 要执行的命令数组
+     * @param pushToHistory 是否将命令推入历史记录，默认为 true
      */
-    executeBatch(commands: Command[]): void;
+    executeBatch(commands: Command[], pushToHistory?: boolean): void;
     /**
      * 清空命令历史
      */
@@ -57,6 +82,13 @@ export declare class CommandSystem {
      * @returns 撤销历史记录数量
      */
     getUndoHistoryCount(): number;
+    /**
+     * 列出所有可用命令
+     */
+    listCommands(): Array<{
+        name: string;
+        description: string;
+    }>;
     /**
      * 构造函数
      * @param option 配置参数

package/dist/src/command/ConcreteCommand.d.ts

@@ -16,14 +16,19 @@ export declare class ConcreteCommand<R extends CommandReceiver> implements Comma
      * 命令描述
      */
     private description;
+    /**
+     * 原始命令字符串
+     */
+    private commandString;
     /**
      * 构造函数
      * @param receiver 命令接收者
      * @param executeFn 执行操作的函数
      * @param undoFn 撤销操作的函数
      * @param description 命令描述
+     * @param commandString 原始命令字符串
      */
-    constructor(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string);
+    constructor(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string, commandString?: string);
     /**
      * 执行命令
      */
@@ -37,6 +42,11 @@ export declare class ConcreteCommand<R extends CommandReceiver> implements Comma
      * @returns 命令描述
      */
     getDescription(): string;
+    /**
+     * 获取原始命令字符串
+     * @returns 命令字符串
+     */
+    getCommandString(): string;
 }
 /**
  * 创建命令的工厂函数
@@ -44,6 +54,7 @@ export declare class ConcreteCommand<R extends CommandReceiver> implements Comma
  * @param executeFn 执行操作的函数
  * @param undoFn 撤销操作的函数
  * @param description 命令描述
+ * @param commandString 原始命令字符串
  * @returns 命令对象
  */
-export declare function createCommand<R extends CommandReceiver>(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string): Command;
+export declare function createCommand<R extends CommandReceiver>(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string, commandString?: string): Command;

package/dist/src/command/index.d.ts

@@ -1,7 +1,5 @@
 /**
  * 命令系统导出文件
  */
-export { CommandInvoker } from './CommandInvoker';
 export { CommandSystem } from './CommandSystem';
-export { ConcreteCommand, createCommand } from './ConcreteCommand';
-export type { Command, CommandReceiver, CommandHistoryItem, TCommandSystemOption, TCommandInvokerOption, TGDMBOption } from './Command';
+export type * from './Command';

package/dist/src/domain/Domain.d.ts

@@ -1,7 +1,9 @@
 import { BaseEvents, Adapter } from '../base-class';
+import { CommandSystem } from '../command';
 import { TEventEmits, VO, IRegisterServiceOption, IRegisterEntityOption, IRegisterVoOptionCache, IRegisterVoOptionContainerCache, IRegisterVoOptionPredicate, IRegisterVoOptionNoCache, TCustomInjectionToken } from '../type';
 import { DomainService } from './DomainService';
 import { DomainEntity } from './DomainEntity';
+import { TCommandSystemOption } from '../command/Command';
 /** 值对象注册配置类型 */
 type TRegisterVoOption<V extends VO<any>> = IRegisterVoOptionCache<V> | IRegisterVoOptionContainerCache<V> | IRegisterVoOptionPredicate<V> | IRegisterVoOptionNoCache<V>;
 /**
@@ -17,6 +19,10 @@ export declare class Domain<E extends TEventEmits = TEventEmits> {
      * @description 领域事件句柄，用于触发、监听、取消监听领域事件
      */
     e: BaseEvents<E>;
+    /**
+     * @description 领域命令句柄，用于注册、执行、撤销、重做领域命令
+     */
+    c: CommandSystem;
     /**
      * @description 向领域依赖注入容器中注册一个或多个领域服务
      * @param service 单个领域服务类或数组
@@ -102,6 +108,6 @@ export declare class Domain<E extends TEventEmits = TEventEmits> {
     /**
      * 域基类构造函数
      */
-    constructor();
+    constructor(options?: TCommandSystemOption);
 }
 export {};

package/dist/src/type.d.ts

@@ -34,11 +34,11 @@ export interface IDomainRegisterOption<D extends Domain> {
     args?: any[];
     /** token 为领域名称的 before resolve拦截函数 */
     beforeResolution?: (token: InjectionToken, resolutionType: string) => void;
-    /** token 为领域名称的 before resolve配置对象  */
+    /** before resolve 拦截器触发评率 */
     beforeResolutionFrequency?: 'Always' | 'Once';
     /** token 为领域名称的 after resolve拦截函数 */
     afterResolution?: (token: InjectionToken, result: D | D[], resolutionType: string) => void;
-    /** token 为领域名称的 after resolve配置对象  */
+    /** after resolve 拦截器触发评率 */
     afterResolutionFrequency?: 'Always' | 'Once';
 }
 /**
@@ -49,8 +49,12 @@ export interface IRegisterEntityOption<E extends DomainEntity> {
     cachePolicy?: 'cache' | 'containerCache' | 'resolution';
     /** before 拦截器函数 */
     beforeResolution?: (token: InjectionToken, resolutionType: string) => void;
+    /** before 拦截器触发评率 */
+    beforeResolutionFrequency?: 'Always' | 'Once';
     /** after 拦截器函数 */
     afterResolution?: (token: InjectionToken, result: E | E[], resolutionType: string) => void;
+    /** after 拦截器触发评率 */
+    afterResolutionFrequency?: 'Always' | 'Once';
 }
 /** 值对象注册配置类型 - 全局缓存缓存 */
 export interface IRegisterVoOptionCache<V extends VO<any> = any> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdmb",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "type": "module",
   "main": "dist/gdmb.umd.js",
   "module": "dist/gdmb.es.js",