gdmb 1.0.0

package/README.md

@@ -0,0 +1,91 @@
+# 项目介绍
+通用领域模型基座，提供领域模型设计开发通用基座能力。依赖 `tsyringe` 提供依赖注入能力。
+
+## 安装
+`npm i gdmb --save`
+
+## 依赖
+
+以下依赖需要在项目中引入
+
+- tsyringe：轻量级依赖注入容器
+- reflect-metadata: 反射元数据
+
+修改 tsconfig.json 配置，开放元数据与反射支持
+``` json
+  "emitDecoratorMetadata": true,
+  "experimentalDecorators": true
+```
+
+## 用例
+
+注册领域、领域服务、领域实体
+
+```typescript
+/** DomainOne.ts */
+import { GDMB, Domain, DomainService, DomainEntity } from 'gdmb';
+
+/** 值对象接口 */
+export interface IVOOne {
+  text: string
+}
+
+/** 实例化gdmb实例对象，全局单例 */
+const gdmb = new GDMB();
+
+/** 领域一 */
+class DomainOne extends Domain {
+  constructor() {
+    super();
+    // 注册服务域
+    this.registerService(ServiceOne);
+    // 注册实体域
+    this.registerEntity(EntityOne);
+    // 注册值对象
+    this.registerValueObject<IVOOne>({
+      token: 'IVOOne',
+      factoryType: 'containerCache',
+      resolveFactory() {
+        return { text: 'this is value object' };
+      }
+    });
+    // 更多使用方法参考类型定义
+  }
+}
+
+/** 服务一 */
+class ServiceOne extends DomainService {}
+
+/** 实体一 */
+class EntityOne extends DomainEntity {}
+
+/** 注册领域 */
+gdmb.registerDomain(DomainOne);
+```
+
+获取领域相关实例
+
+```typescript
+import { GDMB, Domain } from 'gdmb';
+
+/** 实例化gdmb实例对象，全局单例 */
+const gdmb = new GDMB();
+
+// 获取领域对象
+const domainOne = gdmb.domains(DomainOne.name);
+/** 或者 */
+const domainOne = gdmb.domains(DomainOne);
+
+// 获取服务对象
+const serviceOne = domainOne.services(ServiceOne.name);
+/** 或者 */
+const serviceOne = domainOne.services(ServiceOne);
+
+// 获取实体对象
+const entityOne = domainOne.entities(EntityOne.name);
+/** 或者 */
+const entityOne = domainOne.entities(EntityOne);
+
+// 获取值对象
+const voOne = domainOne.vos('IVOOne');
+```

package/dist/gdmb.es.js

@@ -0,0 +1,338 @@
+import { container as l, Lifecycle as a, predicateAwareClassFactory as h, instancePerContainerCachingFactory as g, instanceCachingFactory as d } from "tsyringe";
+class R {
+  /**
+   * 事件容器
+   */
+  _mapper = {};
+  /**
+   * 为使用模块注册事件容器
+   * @param eventName 事件模块名称
+   */
+  register(s) {
+    s in this._mapper || (this._mapper[s] = []);
+  }
+  /**
+   * 删除事件模块
+   */
+  remove(s) {
+    s in this._mapper && delete this._mapper[s];
+  }
+  /**
+   * 事件监听注册
+   * @param eventName 注册事件名称
+   * @param handler 处理器
+   * @returns 监听句柄
+   */
+  on(s, r) {
+    const t = this._mapper[s];
+    t ? t.push(r) : (this.register(s), this.on(s, r));
+  }
+  /**
+   * 移出指定监听函数监听
+   * @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);
+    }
+  }
+  /**
+   * 触发事件
+   * @param eventName 事件名称
+   * @param args 时间回调参数
+   */
+  trigger(s, ...r) {
+    const t = this._mapper[s];
+    t && setTimeout(() => {
+      for (const i of Object.values(t))
+        i(...r);
+    }, 0);
+  }
+  /**
+   * 事件基类的构造函数
+   */
+  constructor() {
+  }
+}
+class v {
+}
+class _ {
+  /**
+   * @summary 领域内部依赖注入容器
+   * @description 领域内部依赖注入容器，用于注册和解析领域服务、实体、值对象等。
+   */
+  dic = l.createChildContainer();
+  /**
+   * @description 领域事件句柄，用于触发、监听、取消监听领域事件
+   */
+  e = new R();
+  /**
+   * @description 向领域依赖注入容器中注册一个或多个领域服务
+   * @param service 单个领域服务类或数组
+   * @param options 领域服务注册配置项，可传入领域服务构造参数以及配置依赖解决拦截器和频率等
+   * @example
+   * ```typescript
+   * class ServiceOne extends DomainService {
+   *   constructor(public arg: string, public arg2: number) {
+   *     super();
+   *   }
+   * }
+   *
+   * domain.registerService(ServiceOne, { args: ['hello', 3] })
+   * // 多个服务时，配置条目允许 undefined 和 null，此时配置会被忽略
+   * domain.registerService([ServiceOne, ServiceTwo], [{ args: ['hello', 3] }, null])
+   * ```
+   */
+  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} 已注册，跳过注册`);
+        continue;
+      }
+      this.dic.register(e.name, { useClass: e }), this.dic.register(e, { useClass: e }), c?.beforeResolution && (this.dic.beforeResolution(e.name, c.beforeResolution, {
+        frequency: c?.beforeResolutionFrequency || "Always"
+      }), this.dic.beforeResolution(e, c.beforeResolution, {
+        frequency: c?.beforeResolutionFrequency || "Always"
+      })), c?.afterResolution && (this.dic.afterResolution(e.name, c.afterResolution, {
+        frequency: c?.afterResolutionFrequency || "Always"
+      }), this.dic.afterResolution(e, c?.afterResolution, {
+        frequency: c?.afterResolutionFrequency || "Always"
+      }));
+    }
+  }
+  /**
+   * @description 向领域依赖注入容器中注册领域实体，指定缓存策略为'cache'时全局单例。
+   * @param entity 单个领域实体类或数组
+   * @param options 领域实体注册配置项
+   * @example
+   * ```typescript
+   * class EntityOne extends DomainEntity {
+   *   constructor(public arg: string, public arg2: number) {
+   *     super();
+   *   }
+   * }
+   *
+   * domain.registerEntity(EntityOne, { args: ['hello', 3] })
+   * // 多个实体时，配置条目允许 undefined 和 null，此时配置会被忽略
+   * domain.registerEntity([EntityOne, EntityTwo], [{ args: ['hello', 3] }, null])
+   * ```
+   */
+  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} 已注册，跳过注册`);
+        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 });
+            break;
+          case "containerCache":
+            this.dic.register(e.name, { useClass: e }, { lifecycle: a.ContainerScoped }), this.dic.register(e, { useClass: e }, { 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 });
+            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, {
+        frequency: "Always"
+      }), this.dic.beforeResolution(e, c.beforeResolution, {
+        frequency: "Always"
+      })), c?.afterResolution && (this.dic.afterResolution(e.name, c.afterResolution, {
+        frequency: "Always"
+      }), this.dic.afterResolution(e, 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(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];
+        switch (i.factoryType) {
+          case "cache":
+            l.register(c, { useFactory: d(i.resolveFactory) });
+            break;
+          case "containerCache":
+            this.dic.register(c, { useFactory: g(i.resolveFactory) });
+            break;
+          case "predicate":
+            this.dic.register(c, {
+              useFactory: h(
+                i.resolveFactory,
+                i.positiveTarget,
+                i.negativeTarget
+              )
+            });
+            break;
+          default:
+            this.dic.register(c, { useFactory: i.resolveFactory });
+            break;
+        }
+      }
+    }
+  }
+  /**
+   * @description 从依赖注入容器中获取领域服务实例对象
+   * @param token 领域服务token
+   * @returns 领域服务实例对象
+   */
+  services(s) {
+    const r = this.dic.resolve(s);
+    return r && !r?.e && (r.e = this.e), r;
+  }
+  /**
+   * @description 从依赖注入容器中获取领域实体实例对象
+   * @param sourceToken 源领域实体token，存在适配器时是 DEF 泛型类型，否则为 DE 泛型类型
+   * @param adapter 领域实体适配器，将 DEF 类型转换为 DE 类型
+   * @returns 领域实体实例对象
+   */
+  entities(s, r) {
+    let t;
+    if (r) {
+      const i = this.dic.resolve(s);
+      t = r.transform(i);
+    } else
+      t = this.dic.resolve(s);
+    return t && !t?.e && (t.e = this.e), t;
+  }
+  /**
+   * @description 从依赖注入容器中获取领域值对象实例对象
+   * @param sourceToken 源领域值对象token，存在适配器时是 VF 泛型类型，否则为 V 泛型类型
+   * @param adapter 领域值对象适配器，将 VF 类型转换为 V 类型
+   * @returns 领域值对象实例对象
+   */
+  vos(s, r) {
+    if (r) {
+      const t = this.dic.resolve(s);
+      return r.transform(t);
+    } else
+      return this.dic.resolve(s);
+  }
+  /**
+   * 域基类构造函数
+   */
+  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;
+  }
+});
+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);
+  return i;
+};
+let u = class {
+  /** 事件句柄 */
+  e = void 0;
+  /**
+   * 域基类构造函数
+   */
+  constructor() {
+  }
+};
+u = m([
+  y
+], u);
+class w {
+  /** 事件句柄 */
+  e = void 0;
+  /**
+   * 域基类构造函数
+   */
+  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);
+  return i;
+};
+let f = class {
+  /** 全局 DIC */
+  globalDIC = l;
+  /**
+   * 注册领域对象
+   */
+  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} 已注册，无法重复注册`);
+        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"
+      }));
+    }
+  }
+  /**
+   * 获取领域对象
+   */
+  domains(n) {
+    return this.globalDIC.resolve(n);
+  }
+  /**
+   * 提供全局的转换方法
+   */
+  transform(n, s) {
+    return s.transform(n);
+  }
+  /**
+   * 提供全局的转换方法，支持批量转换
+   */
+  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);
+    }
+    return r;
+  }
+};
+f = A([
+  y
+], f);
+export {
+  v as Adapter,
+  _ as Domain,
+  w as DomainEntity,
+  u as DomainService,
+  f as GDMB
+};

package/dist/gdmb.umd.js

@@ -0,0 +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"})}));

package/dist/src/base-class/Adapter.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 适配器基类
+ */
+export declare abstract class Adapter<T, F> {
+    /**
+     * @summary 抽象方法，自定义转换函数
+     */
+    abstract transform(source: F): T | undefined;
+}

package/dist/src/base-class/BaseEvent.d.ts

@@ -0,0 +1,42 @@
+import { IAnyObject, TEventEmits } from '../type';
+/**
+ * 自定义事件基类
+ */
+export declare class BaseEvents<E extends TEventEmits = IAnyObject> {
+    /**
+     * 事件容器
+     */
+    private _mapper;
+    /**
+     * 为使用模块注册事件容器
+     * @param eventName 事件模块名称
+     */
+    private register;
+    /**
+     * 删除事件模块
+     */
+    protected remove(eventName: keyof E): void;
+    /**
+     * 事件监听注册
+     * @param eventName 注册事件名称
+     * @param handler 处理器
+     * @returns 监听句柄
+     */
+    on<K extends keyof E>(eventName: K, handler: (...args: E[K]) => void): void;
+    /**
+     * 移出指定监听函数监听
+     * @param eventName 事件名称
+     * @param handler 监听函数
+     */
+    off<K extends keyof E>(eventName: K, handler: (...args: E[K]) => void): void;
+    /**
+     * 触发事件
+     * @param eventName 事件名称
+     * @param args 时间回调参数
+     */
+    trigger<K extends keyof E>(eventName: K, ...args: E[K]): void;
+    /**
+     * 事件基类的构造函数
+     */
+    constructor();
+}

package/dist/src/base-class/index.d.ts

@@ -0,0 +1,2 @@
+export * from './BaseEvent';
+export * from './Adapter';

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

@@ -0,0 +1 @@
+export * from './singleton-decorator';

package/dist/src/decorators/singleton-decorator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 单例装饰器
+ */
+export declare const SingletenDecorator: <T extends {
+    new (...args: any[]): object;
+}>(target: T) => T;

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

@@ -0,0 +1,95 @@
+import { BaseEvents, Adapter } from '../base-class';
+import { TEventEmits, VO, IRegisterServiceOption, IRegisterEntityOption, IRegisterVoOptionCache, IRegisterVoOptionContainerCache, IRegisterVoOptionPredicate, IRegisterVoOptionNoCache, TCustomInjectionToken } from '../type';
+import { DomainService } from './DomainService';
+import { DomainEntity } from './DomainEntity';
+/** 值对象注册配置类型 */
+type TRegisterVoOption<V extends VO<any>> = IRegisterVoOptionCache<V> | IRegisterVoOptionContainerCache<V> | IRegisterVoOptionPredicate<V> | IRegisterVoOptionNoCache<V>;
+/**
+ * 领域对象类
+ */
+export declare class Domain<E extends TEventEmits = TEventEmits> {
+    /**
+     * @summary 领域内部依赖注入容器
+     * @description 领域内部依赖注入容器，用于注册和解析领域服务、实体、值对象等。
+     */
+    dic: import('tsyringe').DependencyContainer;
+    /**
+     * @description 领域事件句柄，用于触发、监听、取消监听领域事件
+     */
+    e: BaseEvents<E>;
+    /**
+     * @description 向领域依赖注入容器中注册一个或多个领域服务
+     * @param service 单个领域服务类或数组
+     * @param options 领域服务注册配置项，可传入领域服务构造参数以及配置依赖解决拦截器和频率等
+     * @example
+     * ```typescript
+     * class ServiceOne extends DomainService {
+     *   constructor(public arg: string, public arg2: number) {
+     *     super();
+     *   }
+     * }
+     *
+     * domain.registerService(ServiceOne, { args: ['hello', 3] })
+     * // 多个服务时，配置条目允许 undefined 和 null，此时配置会被忽略
+     * domain.registerService([ServiceOne, ServiceTwo], [{ args: ['hello', 3] }, null])
+     * ```
+     */
+    registerService<S extends DomainService>(service: (new (...args: any[]) => S) | Array<new (...args: any[]) => S>, options?: IRegisterServiceOption<S> | (IRegisterServiceOption<S> | undefined | null)[]): void;
+    /**
+     * @description 向领域依赖注入容器中注册领域实体，指定缓存策略为'cache'时全局单例。
+     * @param entity 单个领域实体类或数组
+     * @param options 领域实体注册配置项
+     * @example
+     * ```typescript
+     * class EntityOne extends DomainEntity {
+     *   constructor(public arg: string, public arg2: number) {
+     *     super();
+     *   }
+     * }
+     *
+     * domain.registerEntity(EntityOne, { args: ['hello', 3] })
+     * // 多个实体时，配置条目允许 undefined 和 null，此时配置会被忽略
+     * domain.registerEntity([EntityOne, EntityTwo], [{ args: ['hello', 3] }, null])
+     * ```
+     */
+    registerEntity<E extends DomainEntity>(entity: (new (...args: any[]) => E) | Array<new (...args: any[]) => E>, options?: IRegisterEntityOption<E> | (IRegisterEntityOption<E> | undefined | null)[]): void;
+    /**
+     * @summary 项领域内依赖注入容器中注册值对象，当指定 factoryType 为'cache'时全局单例。
+     * @description 需要泛型类型 V，约束工厂函数返回类型，V 满足 VO 类型约束，不允许包含函数属性
+     * @param vos 值对象注册配置项
+     * @example
+     * ```typescript
+     * domain.registerVO({
+     *   token: 'VO1',
+     *   factoryType: 'cache',
+     *   resolveFactory: () => ({ date: '2023-01-01' })
+     * })
+     * ```
+     */
+    registerVO<V extends VO<any>>(vos: TRegisterVoOption<V>): void;
+    /**
+     * @description 从依赖注入容器中获取领域服务实例对象
+     * @param token 领域服务token
+     * @returns 领域服务实例对象
+     */
+    services<S extends DomainService = DomainService>(token: TCustomInjectionToken): S | undefined;
+    /**
+     * @description 从依赖注入容器中获取领域实体实例对象
+     * @param sourceToken 源领域实体token，存在适配器时是 DEF 泛型类型，否则为 DE 泛型类型
+     * @param adapter 领域实体适配器，将 DEF 类型转换为 DE 类型
+     * @returns 领域实体实例对象
+     */
+    entities<DE extends DomainEntity = DomainEntity, DEF extends DomainEntity = 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;
+    /**
+     * 域基类构造函数
+     */
+    constructor();
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { BaseEvents } from '../base-class';
+import { IAnyObject, TEventEmits } from '../type';
+/**
+ * 领域实体基类
+ */
+export declare class DomainEntity<E extends TEventEmits = IAnyObject> {
+    /** 事件句柄 */
+    e: BaseEvents<E> | undefined;
+    /**
+     * 域基类构造函数
+     */
+    constructor();
+}

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

@@ -0,0 +1,13 @@
+import { BaseEvents } from '../base-class';
+import { IAnyObject, TEventEmits } from '../type';
+/**
+ * 领域服务基类
+ */
+export declare class DomainService<E extends TEventEmits = IAnyObject> {
+    /** 事件句柄 */
+    e: BaseEvents<E> | undefined;
+    /**
+     * 域基类构造函数
+     */
+    constructor();
+}

package/dist/src/index.d.ts

@@ -0,0 +1,26 @@
+import { Adapter } from './base-class';
+import { Domain } from './domain/Domain';
+import { IDomainRegisterOption, TCustomInjectionToken } from './type';
+/**
+ * gdmb 对象类
+ */
+export declare class GDMB {
+    /** 全局 DIC */
+    globalDIC: import('tsyringe').DependencyContainer;
+    /**
+     * 注册领域对象
+     */
+    registerDomain<D extends Domain>(domain: new (...args: any[]) => D, option?: IDomainRegisterOption<D>): void;
+    /**
+     * 获取领域对象
+     */
+    domains<D extends Domain>(token: TCustomInjectionToken): D;
+    /**
+     * 提供全局的转换方法
+     */
+    transform<T, TF>(source: TF, adapter: Adapter<T, TF>): T | undefined | null;
+    /**
+     * 提供全局的转换方法，支持批量转换
+     */
+    transformAll<T, TF>(source: TF[], adapter: Adapter<T, TF>): T[];
+}

package/dist/src/main.d.ts

@@ -0,0 +1,8 @@
+import { Adapter } from './base-class';
+import { TEventEmits, VO, IDomainRegisterOption, IRegisterServiceOption, IRegisterEntityOption } from './type';
+export * from './domain/Domain';
+export * from './domain/DomainService';
+export * from './domain/DomainEntity';
+export * from './index';
+export { Adapter };
+export type { TEventEmits, VO, IDomainRegisterOption, IRegisterServiceOption, IRegisterEntityOption };

package/dist/src/type.d.ts

@@ -0,0 +1,111 @@
+import { DependencyContainer, InjectionToken } from 'tsyringe';
+import { Domain } from './domain/Domain';
+import { DomainService } from './domain/DomainService';
+import { DomainEntity } from './domain/DomainEntity';
+import { constructor } from 'tsyringe/dist/typings/types';
+/** 任意扁平对象 */
+export interface IAnyObject<D = any> {
+    [k: string | symbol]: D;
+}
+/**
+ * 事件注册对象类型
+ */
+export type TEventEmits = IAnyObject<any[]>;
+/** 自定义注入令牌类型 */
+export type TCustomInjectionToken<T = any> = string | constructor<T>;
+/**
+ * 服务注册配置项目接口
+ */
+export interface IRegisterServiceOption<S extends DomainService> {
+    /** before 拦截器函数 */
+    beforeResolution?: (token: InjectionToken, resolutionType: string) => void;
+    /** before 拦截器触发评率 */
+    beforeResolutionFrequency?: 'Always' | 'Once';
+    /** after 拦截器函数 */
+    afterResolution?: (token: InjectionToken, result: S | S[], resolutionType: string) => void;
+    /** after 拦截器触发评率 */
+    afterResolutionFrequency?: 'Always' | 'Once';
+}
+/**
+ * 领域对象注册配置接口
+ */
+export interface IDomainRegisterOption<D extends Domain> {
+    /** 注册参数，将带回领域对象类构造函数 */
+    args?: any[];
+    /** token 为领域名称的 before resolve拦截函数 */
+    beforeResolution?: (token: InjectionToken, resolutionType: string) => void;
+    /** token 为领域名称的 before resolve配置对象  */
+    beforeResolutionFrequency?: 'Always' | 'Once';
+    /** token 为领域名称的 after resolve拦截函数 */
+    afterResolution?: (token: InjectionToken, result: D | D[], resolutionType: string) => void;
+    /** token 为领域名称的 after resolve配置对象  */
+    afterResolutionFrequency?: 'Always' | 'Once';
+}
+/**
+ * 实体注册配置接口
+ */
+export interface IRegisterEntityOption<E extends DomainEntity> {
+    /** 缓存策略 */
+    cachePolicy?: 'cache' | 'containerCache' | 'resolution';
+    /** before 拦截器函数 */
+    beforeResolution?: (token: InjectionToken, resolutionType: string) => void;
+    /** after 拦截器函数 */
+    afterResolution?: (token: InjectionToken, result: E | E[], resolutionType: string) => void;
+}
+/** 值对象注册配置类型 - 全局缓存缓存 */
+export interface IRegisterVoOptionCache<V extends VO<any> = any> {
+    token: TCustomInjectionToken | TCustomInjectionToken[];
+    factoryType: 'cache';
+    /** 工厂函数 */
+    resolveFactory: VOFactory<V>;
+}
+/** 值对象注册配置类型 - 容器缓存缓存 */
+export interface IRegisterVoOptionContainerCache<V extends VO<any> = any> {
+    token: TCustomInjectionToken | TCustomInjectionToken[];
+    factoryType: 'containerCache';
+    /** 工厂函数 */
+    resolveFactory: VOFactory<V>;
+}
+/** 值对象注册配置类型 - 条件resolve */
+export interface IRegisterVoOptionPredicate<V extends VO<any> = any> {
+    token: TCustomInjectionToken | TCustomInjectionToken[];
+    factoryType: 'predicate';
+    /** 正值目标 */
+    positiveTarget: new (...args: any[]) => V;
+    /** 负值目标 */
+    negativeTarget: new (...args: any[]) => V;
+    /** 工厂函数 */
+    resolveFactory: VOConditionFactory<V>;
+}
+/** 值对象注册配置类型 - 无缓存 */
+export interface IRegisterVoOptionNoCache<V extends VO<any> = any> {
+    token: TCustomInjectionToken | TCustomInjectionToken[];
+    factoryType: 'noCache';
+    /** 工厂函数 */
+    resolveFactory: VOFactory<V>;
+}
+type NonFunction<T> = T extends (...args: any[]) => any ? never : T;
+/**
+ * 值对象类型约束
+ * @example
+ * ```ts
+ * interface TVODateTime {
+ *   date: string;
+ * }
+ * const vo: VO<TVODateTime> = {
+ *   date: '2023-01-01',
+ * };
+ * ```
+ */
+export type VO<T extends IAnyObject<NonFunction<any>>> = {
+    [K in keyof T]: NonFunction<T[K]>;
+};
+/**
+ * 直接值对象工厂类型约束
+ */
+export type VOFactory<T extends VO<any>> = (c?: DependencyContainer) => VO<T>;
+/**
+ * 条件值对象工厂类型约束
+ */
+export type VOConditionFactory<T extends VO<any>> = (c?: DependencyContainer, positiveTarget?: new (...args: any[]) => T, negativeTarget?: new (...args: any[]) => T) => boolean;
+export {};

package/dist/src/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 判断一个数组是否是二维数组
+ * @param arr 要检查的数组
+ * @returns 是否为二维数组
+ */
+export declare const is2DArray: (arr?: Array<any>) => arr is any[][];

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "gdmb",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/gdmb.umd.js",
+  "module": "dist/gdmb.es.js",
+  "types": "dist/src/main.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -b && vite build -c vitest.config.ts",
+    "build:watch": "tsc -b && vite build --watch -c vitest.config.ts",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage"
+  },
+  "keywords": [],
+  "author": "yzh",
+  "license": "MIT",
+  "description": "",
+  "devDependencies": {
+    "@types/node": "^24.2.1",
+    "eslint": "^9.33.0",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.3.0",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.39.1",
+    "vite": "^7.1.2",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "tsyringe": "^4.10.0"
+  }
+}