gdmb 1.0.0 → 1.2.0

package/dist/gdmb.es.js

@@ -1,5 +1,5 @@
-import { container as l, Lifecycle as a, predicateAwareClassFactory as h, instancePerContainerCachingFactory as g, instanceCachingFactory as d } from "tsyringe";
-class R {
+import { container as l, Lifecycle as a, predicateAwareClassFactory as f, instancePerContainerCachingFactory as d, instanceCachingFactory as g } from "tsyringe";
+class m {
   /**
    * 事件容器
    */
@@ -8,14 +8,14 @@ class R {
    * 为使用模块注册事件容器
    * @param eventName 事件模块名称
    */
-  register(s) {
-    s in this._mapper || (this._mapper[s] = []);
+  register(e) {
+    e in this._mapper || (this._mapper[e] = []);
   }
   /**
    * 删除事件模块
    */
-  remove(s) {
-    s in this._mapper && delete this._mapper[s];
+  remove(e) {
+    e in this._mapper && delete this._mapper[e];
   }
   /**
    * 事件监听注册
@@ -23,20 +23,20 @@ class R {
    * @param handler 处理器
    * @returns 监听句柄
    */
-  on(s, r) {
-    const t = this._mapper[s];
-    t ? t.push(r) : (this.register(s), this.on(s, r));
+  on(e, s) {
+    const r = this._mapper[e];
+    r ? r.push(s) : (this.register(e), this.on(e, s));
   }
   /**
    * 移出指定监听函数监听
    * @param eventName 事件名称
    * @param handler 监听函数
    */
-  off(s, r) {
-    const t = this._mapper[s];
-    if (t) {
-      const i = t.indexOf(r);
-      i !== -1 && t.splice(i, 1);
+  off(e, s) {
+    const r = this._mapper[e];
+    if (r) {
+      const i = r.indexOf(s);
+      i !== -1 && r.splice(i, 1);
     }
   }
   /**
@@ -44,11 +44,11 @@ class R {
    * @param eventName 事件名称
    * @param args 时间回调参数
    */
-  trigger(s, ...r) {
-    const t = this._mapper[s];
-    t && setTimeout(() => {
-      for (const i of Object.values(t))
-        i(...r);
+  trigger(e, ...s) {
+    const r = this._mapper[e];
+    r && setTimeout(() => {
+      for (const i of Object.values(r))
+        i(...s);
     }, 0);
   }
   /**
@@ -57,9 +57,9 @@ class R {
   constructor() {
   }
 }
-class v {
-}
 class _ {
+}
+class w {
   /**
    * @summary 领域内部依赖注入容器
    * @description 领域内部依赖注入容器，用于注册和解析领域服务、实体、值对象等。
@@ -68,7 +68,7 @@ class _ {
   /**
    * @description 领域事件句柄，用于触发、监听、取消监听领域事件
    */
-  e = new R();
+  e = new m();
   /**
    * @description 向领域依赖注入容器中注册一个或多个领域服务
    * @param service 单个领域服务类或数组
@@ -76,31 +76,37 @@ class _ {
    * @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, { args: ['hello', 3] })
-   * // 多个服务时，配置条目允许 undefined 和 null，此时配置会被忽略
-   * domain.registerService([ServiceOne, ServiceTwo], [{ args: ['hello', 3] }, null])
+   * // 注册领域服务
+   * domain.registerService(ServiceOne, { beforeResolution: ServiceOne.beforeResolution, afterResolution: ServiceOne.afterResolution })
    * ```
    */
-  registerService(s, r) {
-    const t = Array.isArray(s) ? s : [s], i = r ? Array.isArray(r) ? r : [r] : [];
-    for (let o = 0; o < t.length; o += 1) {
-      const e = t[o], c = i[o];
-      if (this.dic.isRegistered(e.name) || this.dic.isRegistered(e)) {
-        console.warn(`服务 ${e.name} 已注册，跳过注册`);
+  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(e.name, { useClass: e }), this.dic.register(e, { useClass: e }), c?.beforeResolution && (this.dic.beforeResolution(e.name, c.beforeResolution, {
+      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(e, c.beforeResolution, {
+      }), this.dic.beforeResolution(t, c.beforeResolution, {
         frequency: c?.beforeResolutionFrequency || "Always"
-      })), c?.afterResolution && (this.dic.afterResolution(e.name, c.afterResolution, {
+      })), c?.afterResolution && (this.dic.afterResolution(t.name, c.afterResolution, {
         frequency: c?.afterResolutionFrequency || "Always"
-      }), this.dic.afterResolution(e, c?.afterResolution, {
+      }), this.dic.afterResolution(t, c?.afterResolution, {
         frequency: c?.afterResolutionFrequency || "Always"
       }));
     }
@@ -112,45 +118,51 @@ class _ {
    * @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, { args: ['hello', 3] })
-   * // 多个实体时，配置条目允许 undefined 和 null，此时配置会被忽略
-   * domain.registerEntity([EntityOne, EntityTwo], [{ args: ['hello', 3] }, null])
+   * // 注册领域实体
+   * domain.registerEntity(EntityOne, { cachePolicy: 'cache', beforeResolution: EntityOne.beforeResolution, afterResolution: EntityOne.afterResolution })
    * ```
    */
-  registerEntity(s, r) {
-    const t = Array.isArray(s) ? s : [s], i = r ? Array.isArray(r) ? r : [r] : [];
-    for (let o = 0; o < t.length; o += 1) {
-      const e = t[o], c = i[o];
-      if (this.dic.isRegistered(e.name) || this.dic.isRegistered(e)) {
-        console.warn(`实体 ${e.name} 已注册，跳过注册`);
+  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(e.name, { useClass: e }, { lifecycle: a.Singleton }), l.register(e, { useClass: e }, { lifecycle: a.Singleton });
+            l.register(t.name, { useClass: t }, { lifecycle: a.Singleton }), l.register(t, { useClass: t }, { lifecycle: a.Singleton });
             break;
           case "containerCache":
-            this.dic.register(e.name, { useClass: e }, { lifecycle: a.ContainerScoped }), this.dic.register(e, { useClass: e }, { lifecycle: a.ContainerScoped });
+            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(e.name, { useClass: e }, { lifecycle: a.ResolutionScoped }), this.dic.register(e, { useClass: e }, { lifecycle: a.ResolutionScoped });
+            this.dic.register(t.name, { useClass: t }, { lifecycle: a.ResolutionScoped }), this.dic.register(t, { useClass: t }, { lifecycle: a.ResolutionScoped });
             break;
         }
       else
-        this.dic.register(e.name, { useClass: e }, { lifecycle: a.Transient }), this.dic.register(e, { useClass: e }, { lifecycle: a.Transient });
-      c?.beforeResolution && (this.dic.beforeResolution(e.name, c.beforeResolution, {
+        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(e, c.beforeResolution, {
+      }), this.dic.beforeResolution(t, c.beforeResolution, {
         frequency: "Always"
-      })), c?.afterResolution && (this.dic.afterResolution(e.name, c.afterResolution, {
+      })), c?.afterResolution && (this.dic.afterResolution(t.name, c.afterResolution, {
         frequency: "Always"
-      }), this.dic.afterResolution(e, c.afterResolution, {
+      }), this.dic.afterResolution(t, c.afterResolution, {
         frequency: "Always"
       }));
     }
@@ -168,22 +180,22 @@ class _ {
    * })
    * ```
    */
-  registerVO(s) {
-    const r = Array.isArray(s) ? s : [s];
-    for (let t = 0; t < r.length; t += 1) {
-      const i = r[t], o = Array.isArray(i.token) ? i.token : [i.token];
-      for (let e = 0; e < o.length; e += 1) {
-        const c = o[e];
+  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: d(i.resolveFactory) });
+            l.register(c, { useFactory: g(i.resolveFactory) });
             break;
           case "containerCache":
-            this.dic.register(c, { useFactory: g(i.resolveFactory) });
+            this.dic.register(c, { useFactory: d(i.resolveFactory) });
             break;
           case "predicate":
             this.dic.register(c, {
-              useFactory: h(
+              useFactory: f(
                 i.resolveFactory,
                 i.positiveTarget,
                 i.negativeTarget
@@ -202,9 +214,9 @@ class _ {
    * @param token 领域服务token
    * @returns 领域服务实例对象
    */
-  services(s) {
-    const r = this.dic.resolve(s);
-    return r && !r?.e && (r.e = this.e), r;
+  services(e) {
+    const s = this.dic.resolve(e);
+    return s && !s?.e && (s.e = this.e), s;
   }
   /**
    * @description 从依赖注入容器中获取领域实体实例对象
@@ -212,14 +224,14 @@ class _ {
    * @param adapter 领域实体适配器，将 DEF 类型转换为 DE 类型
    * @returns 领域实体实例对象
    */
-  entities(s, r) {
-    let t;
-    if (r) {
-      const i = this.dic.resolve(s);
-      t = r.transform(i);
+  entities(e, s) {
+    let r;
+    if (s) {
+      const i = this.dic.resolve(e);
+      r = s.transform(i);
     } else
-      t = this.dic.resolve(s);
-    return t && !t?.e && (t.e = this.e), t;
+      r = this.dic.resolve(e);
+    return r && !r?.e && (r.e = this.e), r;
   }
   /**
    * @description 从依赖注入容器中获取领域值对象实例对象
@@ -227,12 +239,12 @@ class _ {
    * @param adapter 领域值对象适配器，将 VF 类型转换为 V 类型
    * @returns 领域值对象实例对象
    */
-  vos(s, r) {
-    if (r) {
-      const t = this.dic.resolve(s);
-      return r.transform(t);
+  vos(e, s) {
+    if (s) {
+      const r = this.dic.resolve(e);
+      return s.transform(r);
     } else
-      return this.dic.resolve(s);
+      return this.dic.resolve(e);
   }
   /**
    * 域基类构造函数
@@ -240,14 +252,14 @@ class _ {
   constructor() {
   }
 }
-const y = (n) => (n.prototype.$ins = null, class extends n {
-  constructor(...s) {
-    return super(...s), n.prototype.$ins || (n.prototype.$ins = this), n.prototype.$ins;
+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, m = (n, s, r, t) => {
-  for (var i = t > 1 ? void 0 : t ? p(s, r) : s, o = n.length - 1, e; o >= 0; o--)
-    (e = n[o]) && (i = e(i) || i);
+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 {
@@ -259,10 +271,10 @@ let u = class {
   constructor() {
   }
 };
-u = m([
+u = v([
   y
 ], u);
-class w {
+class F {
   /** 事件句柄 */
   e = void 0;
   /**
@@ -271,68 +283,319 @@ class w {
   constructor() {
   }
 }
-var b = Object.getOwnPropertyDescriptor, A = (n, s, r, t) => {
-  for (var i = t > 1 ? void 0 : t ? b(s, r) : s, o = n.length - 1, e; o >= 0; o--)
-    (e = n[o]) && (i = e(i) || i);
+class R {
+  /**
+   * 命令历史记录
+   */
+  history = [];
+  /**
+   * 撤销历史记录
+   */
+  undoHistory = [];
+  /**
+   * 命令历史最大深度
+   */
+  maxHistoryDepth;
+  /**
+   * 撤销历史最大深度
+   */
+  maxUndoHistoryDepth;
+  /**
+   * 执行命令
+   * @param command 要执行的命令
+   */
+  execute(e) {
+    e.execute(), this.history.push({
+      command: e,
+      timestamp: Date.now()
+    }), this.undoHistory = [], this.history.length > this.maxHistoryDepth && this.history.shift();
+  }
+  /**
+   * 撤销上一个命令
+   * @returns 是否成功撤销
+   */
+  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;
+  }
+  /**
+   * 重做上一个撤销的命令
+   * @returns 是否成功重做
+   */
+  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;
+  }
+  /**
+   * 批量执行命令
+   * @param commands 要执行的命令数组
+   */
+  executeBatch(e) {
+    e.forEach((s) => this.execute(s));
+  }
+  /**
+   * 清空命令历史
+   */
+  clearHistory() {
+    this.history = [], this.undoHistory = [];
+  }
+  /**
+   * 获取命令历史记录
+   * @returns 命令历史记录数组
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * 获取撤销历史记录
+   * @returns 撤销历史记录数组
+   */
+  getUndoHistory() {
+    return [...this.undoHistory];
+  }
+  /**
+   * 获取历史记录数量
+   * @returns 历史记录数量
+   */
+  getHistoryCount() {
+    return this.history.length;
+  }
+  /**
+   * 获取撤销历史记录数量
+   * @returns 撤销历史记录数量
+   */
+  getUndoHistoryCount() {
+    return this.undoHistory.length;
+  }
+  /**
+   * 构造函数
+   * @param option 命令调用者构造配置参数
+   */
+  constructor(e) {
+    this.maxHistoryDepth = e?.maxHistoryDepth || 1 / 0, this.maxUndoHistoryDepth = e?.maxUndoHistoryDepth || 1 / 0;
+  }
+}
+class C {
+  /**
+   * 命令接收者
+   */
+  receiver;
+  /**
+   * 执行操作的函数
+   */
+  executeFn;
+  /**
+   * 撤销操作的函数
+   */
+  undoFn;
+  /**
+   * 命令描述
+   */
+  description;
+  /**
+   * 构造函数
+   * @param receiver 命令接收者
+   * @param executeFn 执行操作的函数
+   * @param undoFn 撤销操作的函数
+   * @param description 命令描述
+   */
+  constructor(e, s, r, i) {
+    this.receiver = e, this.executeFn = s, this.undoFn = r, this.description = i;
+  }
+  /**
+   * 执行命令
+   */
+  execute() {
+    this.executeFn(this.receiver);
+  }
+  /**
+   * 撤销命令
+   */
+  undo() {
+    this.undoFn(this.receiver);
+  }
+  /**
+   * 获取命令描述
+   * @returns 命令描述
+   */
+  getDescription() {
+    return this.description;
+  }
+}
+function H(o, e, s, r) {
+  return new C(o, e, s, r);
+}
+class D {
+  /**
+   * 命令调用者
+   */
+  invoker;
+  /**
+   * 创建命令
+   * @param receiver 命令接收者
+   * @param executeFn 执行操作的函数
+   * @param undoFn 撤销操作的函数
+   * @param description 命令描述
+   * @returns 命令对象
+   */
+  create(e, s, r, i) {
+    return H(e, s, r, i);
+  }
+  /**
+   * 执行命令
+   * @param command 要执行的命令
+   */
+  execute(e) {
+    this.invoker.execute(e);
+  }
+  /**
+   * 撤销上一个命令
+   * @returns 是否成功撤销
+   */
+  undo() {
+    return this.invoker.undo();
+  }
+  /**
+   * 重做上一个撤销的命令
+   * @returns 是否成功重做
+   */
+  redo() {
+    return this.invoker.redo();
+  }
+  /**
+   * 批量执行命令
+   * @param commands 要执行的命令数组
+   */
+  executeBatch(e) {
+    this.invoker.executeBatch(e);
+  }
+  /**
+   * 清空命令历史
+   */
+  clearHistory() {
+    this.invoker.clearHistory();
+  }
+  /**
+   * 获取命令历史记录
+   * @returns 命令历史记录数组
+   */
+  getHistory() {
+    return this.invoker.getHistory();
+  }
+  /**
+   * 获取撤销历史记录
+   * @returns 撤销历史记录数组
+   */
+  getUndoHistory() {
+    return this.invoker.getUndoHistory();
+  }
+  /**
+   * 获取历史记录数量
+   * @returns 历史记录数量
+   */
+  getHistoryCount() {
+    return this.invoker.getHistoryCount();
+  }
+  /**
+   * 获取撤销历史记录数量
+   * @returns 撤销历史记录数量
+   */
+  getUndoHistoryCount() {
+    return this.invoker.getUndoHistoryCount();
+  }
+  /**
+   * 构造函数
+   * @param option 配置参数
+   */
+  constructor(e) {
+    this.invoker = new R({
+      maxHistoryDepth: e?.maxHistoryDepth,
+      maxUndoHistoryDepth: e?.maxUndoHistoryDepth
+    });
+  }
+}
+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);
   return i;
 };
-let f = class {
+let h = class {
   /** 全局 DIC */
   globalDIC = l;
+  /** 命令系统 */
+  c;
   /**
    * 注册领域对象
    */
-  registerDomain(n, s) {
-    const r = Array.isArray(n) ? n : [n], t = s ? Array.isArray(s) ? s : [s] : [];
-    for (let i = 0; i < r.length; i += 1) {
-      const o = r[i], e = t[i];
-      if (this.globalDIC.isRegistered(o.name)) {
-        console.warn(`领域 ${o.name} 已注册，无法重复注册`);
+  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} 已注册，无法重复注册`);
         return;
       }
-      const c = new o(...e?.args || []);
-      this.globalDIC.register(o.name, { useValue: c }), this.globalDIC.register(o, { useValue: c }), e?.beforeResolution && (this.globalDIC.beforeResolution(o.name, e.beforeResolution, {
-        frequency: e.beforeResolutionFrequency || "Always"
-      }), this.globalDIC.beforeResolution(o, e.beforeResolution, {
-        frequency: e.afterResolutionFrequency || "Always"
-      })), e?.afterResolution && (this.globalDIC.afterResolution(o.name, e.afterResolution, {
-        frequency: e.afterResolutionFrequency || "Always"
-      }), this.globalDIC.afterResolution(o, e.afterResolution, {
-        frequency: e.afterResolutionFrequency || "Always"
+      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"
       }));
     }
   }
   /**
    * 获取领域对象
    */
-  domains(n) {
-    return this.globalDIC.resolve(n);
+  domains(o) {
+    return this.globalDIC.resolve(o);
   }
   /**
    * 提供全局的转换方法
    */
-  transform(n, s) {
-    return s.transform(n);
+  transform(o, e) {
+    return e.transform(o);
   }
   /**
    * 提供全局的转换方法，支持批量转换
    */
-  transformAll(n, s) {
-    const r = [];
-    for (let t = 0; t < n.length; t += 1) {
-      const i = s.transform(n[t]);
-      i != null && r.push(i);
+  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);
     }
-    return r;
+    return s;
+  }
+  /**
+   * 构造函数
+   * @param option 配置参数
+   */
+  constructor(o) {
+    this.c = new D({
+      maxHistoryDepth: o?.maxHistoryDepth,
+      maxUndoHistoryDepth: o?.maxUndoHistoryDepth
+    });
   }
 };
-f = A([
+h = x([
   y
-], f);
+], h);
 export {
-  v as Adapter,
-  _ as Domain,
-  w as DomainEntity,
+  _ as Adapter,
+  R as CommandInvoker,
+  D as CommandSystem,
+  C as ConcreteCommand,
+  w as Domain,
+  F as DomainEntity,
   u as DomainService,
-  f as GDMB
+  h as GDMB,
+  H as createCommand
 };

package/dist/gdmb.umd.js

@@ -1 +1 @@
-(function(l,c){typeof exports=="object"&&typeof module<"u"?c(exports,require("tsyringe")):typeof define=="function"&&define.amd?define(["exports","tsyringe"],c):(l=typeof globalThis<"u"?globalThis:l||self,c(l.gdmb={},l.tsyringe))})(this,(function(l,c){"use strict";class y{_mapper={};register(s){s in this._mapper||(this._mapper[s]=[])}remove(s){s in this._mapper&&delete this._mapper[s]}on(s,i){const r=this._mapper[s];r?r.push(i):(this.register(s),this.on(s,i))}off(s,i){const r=this._mapper[s];if(r){const t=r.indexOf(i);t!==-1&&r.splice(t,1)}}trigger(s,...i){const r=this._mapper[s];r&&setTimeout(()=>{for(const t of Object.values(r))t(...i)},0)}constructor(){}}class h{}class d{dic=c.container.createChildContainer();e=new y;registerService(s,i){const r=Array.isArray(s)?s:[s],t=i?Array.isArray(i)?i:[i]:[];for(let n=0;n<r.length;n+=1){const e=r[n],o=t[n];if(this.dic.isRegistered(e.name)||this.dic.isRegistered(e)){console.warn(`服务 ${e.name} 已注册，跳过注册`);continue}this.dic.register(e.name,{useClass:e}),this.dic.register(e,{useClass:e}),o?.beforeResolution&&(this.dic.beforeResolution(e.name,o.beforeResolution,{frequency:o?.beforeResolutionFrequency||"Always"}),this.dic.beforeResolution(e,o.beforeResolution,{frequency:o?.beforeResolutionFrequency||"Always"})),o?.afterResolution&&(this.dic.afterResolution(e.name,o.afterResolution,{frequency:o?.afterResolutionFrequency||"Always"}),this.dic.afterResolution(e,o?.afterResolution,{frequency:o?.afterResolutionFrequency||"Always"}))}}registerEntity(s,i){const r=Array.isArray(s)?s:[s],t=i?Array.isArray(i)?i:[i]:[];for(let n=0;n<r.length;n+=1){const e=r[n],o=t[n];if(this.dic.isRegistered(e.name)||this.dic.isRegistered(e)){console.warn(`实体 ${e.name} 已注册，跳过注册`);continue}if(o?.cachePolicy)switch(o.cachePolicy){case"cache":c.container.register(e.name,{useClass:e},{lifecycle:c.Lifecycle.Singleton}),c.container.register(e,{useClass:e},{lifecycle:c.Lifecycle.Singleton});break;case"containerCache":this.dic.register(e.name,{useClass:e},{lifecycle:c.Lifecycle.ContainerScoped}),this.dic.register(e,{useClass:e},{lifecycle:c.Lifecycle.ContainerScoped});break;case"resolution":this.dic.register(e.name,{useClass:e},{lifecycle:c.Lifecycle.ResolutionScoped}),this.dic.register(e,{useClass:e},{lifecycle:c.Lifecycle.ResolutionScoped});break}else this.dic.register(e.name,{useClass:e},{lifecycle:c.Lifecycle.Transient}),this.dic.register(e,{useClass:e},{lifecycle:c.Lifecycle.Transient});o?.beforeResolution&&(this.dic.beforeResolution(e.name,o.beforeResolution,{frequency:"Always"}),this.dic.beforeResolution(e,o.beforeResolution,{frequency:"Always"})),o?.afterResolution&&(this.dic.afterResolution(e.name,o.afterResolution,{frequency:"Always"}),this.dic.afterResolution(e,o.afterResolution,{frequency:"Always"}))}}registerVO(s){const i=Array.isArray(s)?s:[s];for(let r=0;r<i.length;r+=1){const t=i[r],n=Array.isArray(t.token)?t.token:[t.token];for(let e=0;e<n.length;e+=1){const o=n[e];switch(t.factoryType){case"cache":c.container.register(o,{useFactory:c.instanceCachingFactory(t.resolveFactory)});break;case"containerCache":this.dic.register(o,{useFactory:c.instancePerContainerCachingFactory(t.resolveFactory)});break;case"predicate":this.dic.register(o,{useFactory:c.predicateAwareClassFactory(t.resolveFactory,t.positiveTarget,t.negativeTarget)});break;default:this.dic.register(o,{useFactory:t.resolveFactory});break}}}}services(s){const i=this.dic.resolve(s);return i&&!i?.e&&(i.e=this.e),i}entities(s,i){let r;if(i){const t=this.dic.resolve(s);r=i.transform(t)}else r=this.dic.resolve(s);return r&&!r?.e&&(r.e=this.e),r}vos(s,i){if(i){const r=this.dic.resolve(s);return i.transform(r)}else return this.dic.resolve(s)}constructor(){}}const f=a=>(a.prototype.$ins=null,class extends a{constructor(...s){return super(...s),a.prototype.$ins||(a.prototype.$ins=this),a.prototype.$ins}});var m=Object.getOwnPropertyDescriptor,R=(a,s,i,r)=>{for(var t=r>1?void 0:r?m(s,i):s,n=a.length-1,e;n>=0;n--)(e=a[n])&&(t=e(t)||t);return t};l.DomainService=class{e=void 0;constructor(){}},l.DomainService=R([f],l.DomainService);class g{e=void 0;constructor(){}}var p=Object.getOwnPropertyDescriptor,b=(a,s,i,r)=>{for(var t=r>1?void 0:r?p(s,i):s,n=a.length-1,e;n>=0;n--)(e=a[n])&&(t=e(t)||t);return t};l.GDMB=class{globalDIC=c.container;registerDomain(s,i){const r=Array.isArray(s)?s:[s],t=i?Array.isArray(i)?i:[i]:[];for(let n=0;n<r.length;n+=1){const e=r[n],o=t[n];if(this.globalDIC.isRegistered(e.name)){console.warn(`领域 ${e.name} 已注册，无法重复注册`);return}const u=new e(...o?.args||[]);this.globalDIC.register(e.name,{useValue:u}),this.globalDIC.register(e,{useValue:u}),o?.beforeResolution&&(this.globalDIC.beforeResolution(e.name,o.beforeResolution,{frequency:o.beforeResolutionFrequency||"Always"}),this.globalDIC.beforeResolution(e,o.beforeResolution,{frequency:o.afterResolutionFrequency||"Always"})),o?.afterResolution&&(this.globalDIC.afterResolution(e.name,o.afterResolution,{frequency:o.afterResolutionFrequency||"Always"}),this.globalDIC.afterResolution(e,o.afterResolution,{frequency:o.afterResolutionFrequency||"Always"}))}}domains(s){return this.globalDIC.resolve(s)}transform(s,i){return i.transform(s)}transformAll(s,i){const r=[];for(let t=0;t<s.length;t+=1){const n=i.transform(s[t]);n!=null&&r.push(n)}return r}},l.GDMB=b([f],l.GDMB),l.Adapter=h,l.Domain=d,l.DomainEntity=g,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 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"})}));

package/dist/skills/gdmb/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: gdmb
+description: 领域驱动设计架构（DDD）专家，专注于处理领域模型相关的任务。可以积极解决领域对象、值对象、实体、聚合根、领域事件、领域服务等领域模型成员的定义、注册、维护、优化和复杂依赖注入的问题，以满足不同应用程序的需求。提供轻量级事件系统和命令系统，支持领域事件的发布和订阅，以及命令的创建和执行。
+category: framework
+---
+
+# 领域驱动设计专家（Domain Driven Design Expert）
+
+你是一个领域驱动设计（DDD）架构专家，对企业级应用程序的DDD架构有深入的理解和实践经验。你熟悉DDD的核心概念，如领域模型、聚合根、值对象、实体、领域事件、领域服务等，并能够根据业务需求设计和实现符合DDD原则的领域模型。
+
+## 当被调用时（When invoked）:
+
+0. 如果有更专业的专家更适合，建议切换并停止：
+   - 纯 TypeScript 问题 → typescript-type-expert
+   - 数据库查询优化问题 → database-expert  
+   - Node.js 运行时问题 → nodejs-expert
+   - 前端 React 问题 → react-expert
+   - 前端 Vue 问题 → vue-expert
+   
+   Example: "这是一个 TypeScript 类型系统问题。请使用 typescript-type-expert 子代理，这里停止。"
+
+1. 识别项目的架构和现有领域模型组件（如聚合根、实体、值对象、领域事件、领域服务等）。
+3. 验证顺序: 类型 → 单元测试 → 集成测试 → 端到端测试
+
+## 领域模型通用模式与解决方案（Common Patterns & Solutions）
+
+### 领域对象创建与注册（Domain Object Creation & Registration）
+```typescript
+import { gdmb, Domain } from 'gdmb';
+// 领域对象类
+class DomainObject extends Domain<DomainEvent> {}
+// 领域对象注册
+gdmb.registerDomain(DomainObject);
+// 从全局对象获取领域对象实例，领域对象实例为全局单例
+const domainObject = gdmb.domains<DomainObject>(DomainObject);
+```
+
+### 领域服务创建与注册（Domain Service Creation & Registration）
+```typescript
+import { gdmb, DomainService } from 'gdmb';
+import type { InjectionToken } from 'tsyringe';
+// 领域服务类
+class DomainServiceObject extends DomainService<DomainEvent> {
+  // 领域服务在解析前调用
+  public static beforeResolution(token: InjectionToken, resolutionType: string) {
+    // resolve 前拦截器这里处理
+  }
+  // 领域服务在解析后调用
+  public static afterResolution(token: InjectionToken, result: DomainServiceObject | DomainServiceObject[], resolutionType: string) {
+    // resovle 后拦截器这里处理
+  }
+}
+// 领域服务注册
+domainObject.registerService(DomainServiceObject, {
+  // 领域服务在解析前调用
+  beforeResolution: DomainServiceObject.beforeResolution,
+  // 领域服务在解析前调用频率，可用值 'Always' | 'Once'
+  beforeResolutionFrequency: 'Once',
+  // 领域服务在解析后调用
+  afterResolution: DomainServiceObject.afterResolution,
+  // 领域服务在解析后调用频率，可用值 'Always' | 'Once'
+  afterResolutionFrequency: 'Always'
+});
+// 从全局对象获取领域服务实例
+const domainService = domainObject.services<DomainService>(DomainService);
+```
+
+### 领域事件定义、触发与监听（Domain Event Definition & Trigger & Listen）
+```typescript
+import { gdmb, Domain } from 'gdmb';
+// 定义领域事件
+type DomainEvent = {
+  /** 事件名称 + 处理函数注入参数数组 */
+  eventName: [arg: number, arg2: string]
+}
+// 领域对象类
+class DomainObject extends Domain<DomainEvent> {
+  constructor() {
+    super();
+    // 事件处理
+    this.e?.trigger('eventName', 1, 'arg2');
+  }
+}
+// 领域注册
+gdmb.registerDomain(DomainObject);
+// 获取领域对象实例
+const domainObject = gdmb.domains<DomainObject>(DomainObject);
+// 监听领域事件
+domainObject.e?.on('eventName', (arg: number, arg2: string) => {
+  // 处理事件
+})
+```
+
+### 领域实体创建与注册（Domain Entity Creation & Registration）
+```typescript
+import { gdmb, Domain, DomainEntity } from 'gdmb';
+// 领域对象类
+class DomainObject extends Domain<DomainEvent> {}
+// 领域对象注册
+gdmb.registerDomain(DomainObject);
+// 领域实体类
+class DomainEntityObject extends DomainEntity<DomainEvent> {
+  // 领域实体在解析前调用
+  public static beforeResolution(token: InjectionToken, resolutionType: string) {
+    // resolve 前拦截器这里处理
+  }
+  // 领域实体在解析后调用
+  public static afterResolution(token: InjectionToken, result: DomainEntityObject | DomainEntityObject[], resolutionType: string) {
+    // resovle 后拦截器这里处理
+  }
+}
+// 获取领域对象
+const domainObject = gdmb.domains<DomainObject>(DomainObject);
+// 领域实体注册
+domainObject.registerEntity(DomainEntityObject, {
+  cachePolicy: 'cache',
+  beforeResolution: DomainEntityObject.beforeResolution,
+  afterResolution: DomainEntityObject.afterResolution
+});
+// 从全局对象获取领域实体实例
+const domainEntity = domainObject.entities<DomainEntityObject>(DomainEntityObject);
+```
+
+### 值对象创建与注册（Value Object Creation & Registration）
+```typescript
+import { gdmb, Domain } from 'gdmb';
+// 定义值对象接口
+interface IVOOne {
+  /** 文本 */
+  text: string;
+  /** 数字 */
+  num: number;
+}
+// 领域对象类
+class DomainObject extends Domain<DomainEvent> {}
+// 领域对象注册
+gdmb.registerDomain(DomainObject);
+// 获取领域对象实例
+const domainObject = gdmb.domains<DomainObject>(DomainObject);
+// 注册值对象
+domainObject.registerVO<IVOOne>({
+  token: 'IVOOne',
+  factoryType: 'containerCache',
+  resolveFactory() {
+    return {
+      text: 'text',
+      num: 1,
+    }
+  }
+});
+// resolve 值对象
+const voOne = domainObject.vos<IVOOne>('IVOOne'); // { text: 'text', num: 1 }
+```
+
+### 命令系统（Command System）
+```typescript
+import { GDMB } from 'gdmb';
+import type { Command, CommandReceiver } from 'gdmb';
+// 实例化全局对象
+const gdmb = new GDMB();
+// 定义命令接受者作为命令执行者
+class CounterReceiver implements CounterReceiver {
+  // 执行函数（必要）
+  executeOperation({ type, value = 1 }: { type: string; value?: number }): void {
+    // 执行函数实现
+  };
+  // 撤销函数（必要）
+  undoOperation({ type, value = 1 }: { type: string; value?: number }): void {
+    // 撤销函数实现
+  };
+}
+// 创建命令对象
+const command = gdmb.c.create(
+  new CounterReceiver(),
+  (r: CounterReceiver) => r.executeOperation({ type: 'increment', value: 5 }),
+  (r: CounterReceiver) => r.undoOperation({ type: 'increment', value: 5 }),
+  '增加计数器值'
+);
+// 执行命令
+gdmb.c.execute(command);
+```
+
+## 代码检查清单（Code Review Checklist）
+
+在审查gdmb应用程序时，请关注:
+
+### 领域结构与依赖注入（Domain Architecture & Dependency Injection）
+- [ ] 所有领域对象（domainObject）都继承自Domain类。通过 gdmb.registerDomain() 注册；通过 gdmb.domains() 获取实例。
+- [ ] 所有领域服务都继承自DomainService类。通过 domainObject.registerService() 注册；通过 domainObject.services() 获取实例。
+- [ ] 所有领域实体都继承自DomainEntity类。通过 domainObject.registerEntity() 注册；通过 domainObject.entities() 获取实例。
+- [ ] 所有值对象只是一个普通接口，必须通过依赖注入实例化。通过 domainObject.registerVO() 注册；通过 domainObject.vos() 获取实例。
+- [ ] 所有领域对象、领域服务、领域实体、值对象都必须在注册后才能使用。
+- [ ] 领域模型之间不存在循环依赖关系。
+
+### 领域事件与命令系统（Domain Event & Command System）
+- [ ] 领域事件句柄绑定在领域对象（domainObject）内，通过 this.e 访问。
+- [ ] 领域服务、领域实体在注册时注入了事件句柄，通过 this.e 访问。
+- [ ] 命令系统绑定在 gdmb 对象上，通过 gdmb.c 访问。
+- [ ] 所有命令接收者都实现CommandReceiver接口。并使用 @injectable() 装饰器函数装饰，实现依赖注入。
+- [ ] 命令对象通过 gdmb.c.create() 创建；通过 gdmb.c.execute() 执行。
+
+### 测试与模拟（Testing & Mocking）
+- [ ] 测试模块尽可能小。
+- [ ] 在测试中，所有 async 操作，都应配合 await 使用。
+
+### 性能与优化（Performance & Optimization）
+- [ ] 缓存是为昂贵的操作实现的
+- [ ] 防止内存泄漏（清除事件侦听器）
+
+## 成功指标（Success Metrics）
+- ✅ 在领域模块中结构中正确识别和定位问题
+- ✅ 解决方案遵循DDD架构模式
+- ✅ 所有测试通过（单元、集成、端到端）
+- ✅ 没有引入循环依赖
+- ✅ 维护或改进了性能指标
+- ✅ 代码遵循既定的项目约定
+- ✅ 实现了正确的错误处理
+- ✅ 应用的安全最佳实践

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

@@ -0,0 +1,55 @@
+/**
+ * 命令接口
+ * 定义执行操作的标准接口
+ */
+export interface Command {
+    /**
+     * 执行命令
+     */
+    execute(): void;
+    /**
+     * 撤销命令
+     */
+    undo(): void;
+    /**
+     * 获取命令描述
+     */
+    getDescription(): string;
+}
+/**
+ * 命令历史记录项
+ */
+export interface CommandHistoryItem {
+    command: Command;
+    timestamp: number;
+}
+/**
+ * 命令接收者接口
+ * 定义命令接收者的标准接口
+ */
+export interface CommandReceiver {
+    /**
+     * 执行命令操作
+     * @param args 命令参数
+     */
+    executeOperation(...args: any[]): void;
+    /**
+     * 撤销命令操作
+     * @param args 命令参数
+     */
+    undoOperation(...args: any[]): void;
+}
+/** 命令调用历史记录最大深度配置参数接口 */
+interface ICommandInvokMaxHistoryDepth {
+    /** 命令历史最大深度，默认为 Infinity（无限制） */
+    maxHistoryDepth?: number;
+    /** 撤销历史最大深度，默认为 Infinity（无限制） */
+    maxUndoHistoryDepth?: number;
+}
+/** 命令调用者构造配置参数 */
+export type TCommandInvokerOption = ICommandInvokMaxHistoryDepth & {};
+/** 命令系统构造配置参数 */
+export type TCommandSystemOption = ICommandInvokMaxHistoryDepth & {};
+/** gdmb 构造函数配置对象 */
+export type TGDMBOption = ICommandInvokMaxHistoryDepth & {};
+export {};

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

@@ -0,0 +1,68 @@
+import { Command, CommandHistoryItem, TCommandInvokerOption } from './Command';
+export declare class CommandInvoker {
+    /**
+     * 命令历史记录
+     */
+    private history;
+    /**
+     * 撤销历史记录
+     */
+    private undoHistory;
+    /**
+     * 命令历史最大深度
+     */
+    private maxHistoryDepth;
+    /**
+     * 撤销历史最大深度
+     */
+    private maxUndoHistoryDepth;
+    /**
+     * 执行命令
+     * @param command 要执行的命令
+     */
+    execute(command: Command): void;
+    /**
+     * 撤销上一个命令
+     * @returns 是否成功撤销
+     */
+    undo(): boolean;
+    /**
+     * 重做上一个撤销的命令
+     * @returns 是否成功重做
+     */
+    redo(): boolean;
+    /**
+     * 批量执行命令
+     * @param commands 要执行的命令数组
+     */
+    executeBatch(commands: Command[]): void;
+    /**
+     * 清空命令历史
+     */
+    clearHistory(): void;
+    /**
+     * 获取命令历史记录
+     * @returns 命令历史记录数组
+     */
+    getHistory(): CommandHistoryItem[];
+    /**
+     * 获取撤销历史记录
+     * @returns 撤销历史记录数组
+     */
+    getUndoHistory(): CommandHistoryItem[];
+    /**
+     * 获取历史记录数量
+     * @returns 历史记录数量
+     */
+    getHistoryCount(): number;
+    /**
+     * 获取撤销历史记录数量
+     * @returns 撤销历史记录数量
+     */
+    getUndoHistoryCount(): number;
+    /**
+     * 构造函数
+     * @param option 命令调用者构造配置参数
+     */
+    constructor(option?: TCommandInvokerOption);
+}

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

@@ -0,0 +1,65 @@
+import { Command, CommandReceiver, CommandHistoryItem, TCommandSystemOption } from './Command';
+export declare class CommandSystem {
+    /**
+     * 命令调用者
+     */
+    private invoker;
+    /**
+     * 创建命令
+     * @param receiver 命令接收者
+     * @param executeFn 执行操作的函数
+     * @param undoFn 撤销操作的函数
+     * @param description 命令描述
+     * @returns 命令对象
+     */
+    create<R extends CommandReceiver>(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string): Command;
+    /**
+     * 执行命令
+     * @param command 要执行的命令
+     */
+    execute(command: Command): void;
+    /**
+     * 撤销上一个命令
+     * @returns 是否成功撤销
+     */
+    undo(): boolean;
+    /**
+     * 重做上一个撤销的命令
+     * @returns 是否成功重做
+     */
+    redo(): boolean;
+    /**
+     * 批量执行命令
+     * @param commands 要执行的命令数组
+     */
+    executeBatch(commands: Command[]): void;
+    /**
+     * 清空命令历史
+     */
+    clearHistory(): void;
+    /**
+     * 获取命令历史记录
+     * @returns 命令历史记录数组
+     */
+    getHistory(): CommandHistoryItem[];
+    /**
+     * 获取撤销历史记录
+     * @returns 撤销历史记录数组
+     */
+    getUndoHistory(): CommandHistoryItem[];
+    /**
+     * 获取历史记录数量
+     * @returns 历史记录数量
+     */
+    getHistoryCount(): number;
+    /**
+     * 获取撤销历史记录数量
+     * @returns 撤销历史记录数量
+     */
+    getUndoHistoryCount(): number;
+    /**
+     * 构造函数
+     * @param option 配置参数
+     */
+    constructor(option?: TCommandSystemOption);
+}

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

@@ -0,0 +1,49 @@
+import { Command, CommandReceiver } from './Command';
+export declare class ConcreteCommand<R extends CommandReceiver> implements Command {
+    /**
+     * 命令接收者
+     */
+    private receiver;
+    /**
+     * 执行操作的函数
+     */
+    private executeFn;
+    /**
+     * 撤销操作的函数
+     */
+    private undoFn;
+    /**
+     * 命令描述
+     */
+    private description;
+    /**
+     * 构造函数
+     * @param receiver 命令接收者
+     * @param executeFn 执行操作的函数
+     * @param undoFn 撤销操作的函数
+     * @param description 命令描述
+     */
+    constructor(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string);
+    /**
+     * 执行命令
+     */
+    execute(): void;
+    /**
+     * 撤销命令
+     */
+    undo(): void;
+    /**
+     * 获取命令描述
+     * @returns 命令描述
+     */
+    getDescription(): string;
+}
+/**
+ * 创建命令的工厂函数
+ * @param receiver 命令接收者
+ * @param executeFn 执行操作的函数
+ * @param undoFn 撤销操作的函数
+ * @param description 命令描述
+ * @returns 命令对象
+ */
+export declare function createCommand<R extends CommandReceiver>(receiver: R, executeFn: (receiver: R) => void, undoFn: (receiver: R) => void, description: string): Command;

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

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

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

@@ -24,17 +24,23 @@ export declare class Domain<E extends TEventEmits = TEventEmits> {
      * @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, { args: ['hello', 3] })
-     * // 多个服务时，配置条目允许 undefined 和 null，此时配置会被忽略
-     * domain.registerService([ServiceOne, ServiceTwo], [{ args: ['hello', 3] }, null])
+     * // 注册领域服务
+     * domain.registerService(ServiceOne, { beforeResolution: ServiceOne.beforeResolution, afterResolution: ServiceOne.afterResolution })
      * ```
      */
-    registerService<S extends DomainService>(service: (new (...args: any[]) => S) | Array<new (...args: any[]) => S>, options?: IRegisterServiceOption<S> | (IRegisterServiceOption<S> | undefined | null)[]): void;
+    registerService<S extends DomainService>(service: new (...args: any[]) => S, options?: IRegisterServiceOption<S>): void;
     /**
      * @description 向领域依赖注入容器中注册领域实体，指定缓存策略为'cache'时全局单例。
      * @param entity 单个领域实体类或数组
@@ -42,17 +48,23 @@ export declare class Domain<E extends TEventEmits = TEventEmits> {
      * @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, { args: ['hello', 3] })
-     * // 多个实体时，配置条目允许 undefined 和 null，此时配置会被忽略
-     * domain.registerEntity([EntityOne, EntityTwo], [{ args: ['hello', 3] }, null])
+     * // 注册领域实体
+     * domain.registerEntity(EntityOne, { cachePolicy: 'cache', beforeResolution: EntityOne.beforeResolution, afterResolution: EntityOne.afterResolution })
      * ```
      */
-    registerEntity<E extends DomainEntity>(entity: (new (...args: any[]) => E) | Array<new (...args: any[]) => E>, options?: IRegisterEntityOption<E> | (IRegisterEntityOption<E> | undefined | null)[]): void;
+    registerEntity<E extends DomainEntity>(entity: new (...args: any[]) => E, options?: IRegisterEntityOption<E>): void;
     /**
      * @summary 项领域内依赖注入容器中注册值对象，当指定 factoryType 为'cache'时全局单例。
      * @description 需要泛型类型 V，约束工厂函数返回类型，V 满足 VO 类型约束，不允许包含函数属性
@@ -79,14 +91,14 @@ export declare class Domain<E extends TEventEmits = TEventEmits> {
      * @param adapter 领域实体适配器，将 DEF 类型转换为 DE 类型
      * @returns 领域实体实例对象
      */
-    entities<DE extends DomainEntity = DomainEntity, DEF extends DomainEntity = DE>(sourceToken: TCustomInjectionToken, adapter?: Adapter<DE, DEF>): DE | undefined;
+    entities<DE extends DomainEntity = DomainEntity, DEF extends DomainEntity | VO<any> = DE>(sourceToken: TCustomInjectionToken, adapter?: Adapter<DE, DEF>): DE | undefined;
     /**
      * @description 从依赖注入容器中获取领域值对象实例对象
      * @param sourceToken 源领域值对象token，存在适配器时是 VF 泛型类型，否则为 V 泛型类型
      * @param adapter 领域值对象适配器，将 VF 类型转换为 V 类型
      * @returns 领域值对象实例对象
      */
-    vos<V extends VO<any> = VO<any>, VF extends VO<any> = V>(sourceToken: TCustomInjectionToken, adapter?: Adapter<V, VF>): V | undefined;
+    vos<V extends VO<any> = VO<any>, VF extends VO<any> | DomainEntity = V>(sourceToken: TCustomInjectionToken, adapter?: Adapter<V, VF>): V | undefined;
     /**
      * 域基类构造函数
      */

package/dist/src/index.d.ts

@@ -1,4 +1,5 @@
 import { Adapter } from './base-class';
+import { CommandSystem, TGDMBOption } from './command';
 import { Domain } from './domain/Domain';
 import { IDomainRegisterOption, TCustomInjectionToken } from './type';
 /**
@@ -7,6 +8,8 @@ import { IDomainRegisterOption, TCustomInjectionToken } from './type';
 export declare class GDMB {
     /** 全局 DIC */
     globalDIC: import('tsyringe').DependencyContainer;
+    /** 命令系统 */
+    c: CommandSystem;
     /**
      * 注册领域对象
      */
@@ -23,4 +26,9 @@ export declare class GDMB {
      * 提供全局的转换方法，支持批量转换
      */
     transformAll<T, TF>(source: TF[], adapter: Adapter<T, TF>): T[];
+    /**
+     * 构造函数
+     * @param option 配置参数
+     */
+    constructor(option?: TGDMBOption);
 }

package/dist/src/main.d.ts

@@ -4,5 +4,6 @@ export * from './domain/Domain';
 export * from './domain/DomainService';
 export * from './domain/DomainEntity';
 export * from './index';
+export * from './command';
 export { Adapter };
 export type { TEventEmits, VO, IDomainRegisterOption, IRegisterServiceOption, IRegisterEntityOption };

package/dist/src/type.d.ts

@@ -10,7 +10,7 @@ export interface IAnyObject<D = any> {
 /**
  * 事件注册对象类型
  */
-export type TEventEmits = IAnyObject<any[]>;
+export type TEventEmits = Record<string, any[]>;
 /** 自定义注入令牌类型 */
 export type TCustomInjectionToken<T = any> = string | constructor<T>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdmb",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "module",
   "main": "dist/gdmb.umd.js",
   "module": "dist/gdmb.es.js",
@@ -27,6 +27,7 @@
     "typescript-eslint": "^8.39.1",
     "vite": "^7.1.2",
     "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-static-copy": "^3.1.6",
     "vitest": "^3.2.4"
   },
   "dependencies": {