@eggjs/tegg-runtime 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/factory/LoadUnitInstanceFactory.d.ts

@@ -1,15 +0,0 @@
-import { EggLoadUnitTypeLike, EggPrototype, LoadUnit, LoadUnitInstance, LoadUnitInstanceLifecycleContext } from "@eggjs/tegg-types";
-
-//#region src/factory/LoadUnitInstanceFactory.d.ts
-type LoadUnitInstanceCreator = (ctx: LoadUnitInstanceLifecycleContext) => LoadUnitInstance;
-declare class LoadUnitInstanceFactory {
-  private static creatorMap;
-  private static instanceMap;
-  static registerLoadUnitInstanceClass(type: EggLoadUnitTypeLike, creator: LoadUnitInstanceCreator): void;
-  static createLoadUnitInstance(loadUnit: LoadUnit): Promise<LoadUnitInstance>;
-  static getLoadUnitInstance(loadUnit: LoadUnit): LoadUnitInstance | undefined;
-  static destroyLoadUnitInstance(loadUnitInstance: LoadUnitInstance): Promise<void>;
-  static getLoadUnitInstanceByProto(proto: EggPrototype): LoadUnitInstance;
-}
-//#endregion
-export { LoadUnitInstanceFactory };

package/dist/factory/LoadUnitInstanceFactory.js

@@ -1,49 +0,0 @@
-import { EggContainerFactory } from "./EggContainerFactory.js";
-import { LoadUnitInstanceLifecycleUtil } from "../model/LoadUnitInstance.js";
-import { ObjectInitType } from "@eggjs/tegg-types";
-import { IdenticalUtil } from "@eggjs/tegg-lifecycle";
-
-//#region src/factory/LoadUnitInstanceFactory.ts
-var LoadUnitInstanceFactory = class {
-	static creatorMap = /* @__PURE__ */ new Map();
-	static instanceMap = /* @__PURE__ */ new Map();
-	static registerLoadUnitInstanceClass(type, creator) {
-		this.creatorMap.set(type, creator);
-	}
-	static async createLoadUnitInstance(loadUnit) {
-		const creator = this.creatorMap.get(loadUnit.type);
-		if (!creator) throw new Error(`load unit instance type ${loadUnit.type} is not implement`);
-		const instanceId = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
-		if (!this.instanceMap.has(instanceId)) {
-			const ctx = { loadUnit };
-			const instance = creator(ctx);
-			this.instanceMap.set(instanceId, {
-				instance,
-				ctx
-			});
-			if (instance.init) await instance.init(ctx);
-		}
-		return this.instanceMap.get(instanceId).instance;
-	}
-	static getLoadUnitInstance(loadUnit) {
-		const instanceId = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
-		return this.instanceMap.get(instanceId)?.instance;
-	}
-	static async destroyLoadUnitInstance(loadUnitInstance) {
-		const { ctx } = this.instanceMap.get(loadUnitInstance.id);
-		await LoadUnitInstanceLifecycleUtil.objectPreDestroy(ctx, loadUnitInstance);
-		if (loadUnitInstance.destroy) await loadUnitInstance.destroy(ctx);
-		this.instanceMap.delete(loadUnitInstance.id);
-		LoadUnitInstanceLifecycleUtil.clearObjectLifecycle(loadUnitInstance);
-	}
-	static getLoadUnitInstanceByProto(proto) {
-		for (const { instance } of this.instanceMap.values()) if (instance.loadUnit.containPrototype(proto)) return instance;
-		throw new Error(`not found load unit for proto ${proto.id}`);
-	}
-};
-EggContainerFactory.registerContainerGetMethod(ObjectInitType.SINGLETON, (proto) => {
-	return LoadUnitInstanceFactory.getLoadUnitInstanceByProto(proto);
-});
-
-//#endregion
-export { LoadUnitInstanceFactory };

package/dist/factory/index.js

@@ -1,5 +0,0 @@
-import { EggContainerFactory } from "./EggContainerFactory.js";
-import { LoadUnitInstanceFactory } from "./LoadUnitInstanceFactory.js";
-import { EggObjectFactory } from "./EggObjectFactory.js";
-
-export {  };

package/dist/impl/ContextInitiator.d.ts

@@ -1,12 +0,0 @@
-import { EggObject, EggRuntimeContext } from "@eggjs/tegg-types";
-
-//#region src/impl/ContextInitiator.d.ts
-declare class ContextInitiator {
-  private readonly eggContext;
-  private readonly eggObjectInitRecorder;
-  constructor(eggContext: EggRuntimeContext);
-  init(obj: EggObject): Promise<void>;
-  static createContextInitiator(context: EggRuntimeContext): ContextInitiator;
-}
-//#endregion
-export { ContextInitiator };

package/dist/impl/ContextInitiator.js

@@ -1,37 +0,0 @@
-import { EggContainerFactory } from "../factory/EggContainerFactory.js";
-import { ContextObjectGraph } from "./ContextObjectGraph.js";
-import "../factory/index.js";
-import { LoadUnitFactory } from "@eggjs/tegg-metadata";
-
-//#region src/impl/ContextInitiator.ts
-const CONTEXT_INITIATOR = Symbol("EggContext#ContextInitiator");
-var ContextInitiator = class ContextInitiator {
-	eggContext;
-	eggObjectInitRecorder;
-	constructor(eggContext) {
-		this.eggContext = eggContext;
-		this.eggObjectInitRecorder = /* @__PURE__ */ new WeakMap();
-		this.eggContext.set(CONTEXT_INITIATOR, this);
-	}
-	async init(obj) {
-		if (this.eggObjectInitRecorder.get(obj) === true) return;
-		this.eggObjectInitRecorder.set(obj, true);
-		const injectObjectProtos = ContextObjectGraph.getContextProto(obj.proto);
-		await Promise.all(injectObjectProtos.map(async (injectObject) => {
-			const proto = injectObject.proto;
-			if (!LoadUnitFactory.getLoadUnitById(proto.loadUnitId)) throw new Error(`can not find load unit: ${proto.loadUnitId}`);
-			await EggContainerFactory.getOrCreateEggObject(proto, injectObject.objName);
-		}));
-	}
-	static createContextInitiator(context) {
-		let initiator = context.get(CONTEXT_INITIATOR);
-		if (!initiator) {
-			initiator = new ContextInitiator(context);
-			context.set(CONTEXT_INITIATOR, initiator);
-		}
-		return initiator;
-	}
-};
-
-//#endregion
-export { ContextInitiator };

package/dist/impl/ContextObjectGraph.d.ts

@@ -1,10 +0,0 @@
-import { EggPrototype, InjectObjectProto } from "@eggjs/tegg-types";
-
-//#region src/impl/ContextObjectGraph.d.ts
-declare class ContextObjectGraph {
-  private static eggObjectInitRecorder;
-  static getContextProto(proto: EggPrototype): InjectObjectProto[];
-  private static doGetContextProto;
-}
-//#endregion
-export { ContextObjectGraph };

package/dist/impl/ContextObjectGraph.js

@@ -1,36 +0,0 @@
-import { ObjectInitType } from "@eggjs/tegg-types";
-
-//#region src/impl/ContextObjectGraph.ts
-var InjectProtoHolder = class {
-	idSet = /* @__PURE__ */ new Set();
-	injectProtos = [];
-	addInjectProto(injectObjectProto) {
-		const id = `${String(injectObjectProto.objName)}:${injectObjectProto.proto.id}`;
-		if (this.idSet.has(id)) return;
-		this.idSet.add(id);
-		this.injectProtos.push(injectObjectProto);
-	}
-	dumpProtos() {
-		return this.injectProtos;
-	}
-};
-var ContextObjectGraph = class ContextObjectGraph {
-	static eggObjectInitRecorder = /* @__PURE__ */ new WeakMap();
-	static getContextProto(proto) {
-		if (ContextObjectGraph.eggObjectInitRecorder.has(proto)) return ContextObjectGraph.eggObjectInitRecorder.get(proto);
-		const holder = new InjectProtoHolder();
-		this.doGetContextProto(proto, holder);
-		const injectObjectProtos = holder.dumpProtos();
-		ContextObjectGraph.eggObjectInitRecorder.set(proto, injectObjectProtos);
-		return injectObjectProtos;
-	}
-	static doGetContextProto(proto, holder) {
-		for (const injectObject of proto.injectObjects) {
-			if (injectObject.proto.initType === ObjectInitType.CONTEXT && proto.initType !== ObjectInitType.CONTEXT) holder.addInjectProto(injectObject);
-			ContextObjectGraph.doGetContextProto(injectObject.proto, holder);
-		}
-	}
-};
-
-//#endregion
-export { ContextObjectGraph };

package/dist/impl/EggAlwaysNewObjectContainer.d.ts

@@ -1,17 +0,0 @@
-import { EggContainer, EggObject, EggObjectName, EggPrototype, Id, LifecycleContext } from "@eggjs/tegg-types";
-
-//#region src/impl/EggAlwaysNewObjectContainer.d.ts
-declare class EggAlwaysNewObjectContainer implements EggContainer<LifecycleContext> {
-  static instance: EggAlwaysNewObjectContainer;
-  readonly id: Id;
-  constructor();
-  addProtoToCreate(): void;
-  deleteProtoToCreate(): void;
-  iterateProtoToCreate(): IterableIterator<[EggObjectName, EggPrototype]>;
-  getEggObject(): EggObject;
-  getOrCreateEggObject(name: string, proto: EggPrototype): Promise<EggObject>;
-  destroy(): Promise<void>;
-  init(): Promise<void>;
-}
-//#endregion
-export { EggAlwaysNewObjectContainer };

package/dist/impl/EggAlwaysNewObjectContainer.js

@@ -1,30 +0,0 @@
-import { EggContainerFactory } from "../factory/EggContainerFactory.js";
-import { EggObjectFactory } from "../factory/EggObjectFactory.js";
-import "../factory/index.js";
-import { ObjectInitType } from "@eggjs/tegg-types";
-
-//#region src/impl/EggAlwaysNewObjectContainer.ts
-var EggAlwaysNewObjectContainer = class EggAlwaysNewObjectContainer {
-	static instance = new EggAlwaysNewObjectContainer();
-	id;
-	constructor() {
-		this.id = "ALWAYS_NEW_OBJECT_CONTAINER";
-	}
-	addProtoToCreate() {}
-	deleteProtoToCreate() {}
-	iterateProtoToCreate() {
-		return (/* @__PURE__ */ new Map()).entries();
-	}
-	getEggObject() {
-		throw new Error("Always Object can not use getEggObject, should use getOrCreateEggObject");
-	}
-	async getOrCreateEggObject(name, proto) {
-		return EggObjectFactory.createObject(name, proto);
-	}
-	async destroy() {}
-	async init() {}
-};
-EggContainerFactory.registerContainerGetMethod(ObjectInitType.ALWAYS_NEW, () => EggAlwaysNewObjectContainer.instance);
-
-//#endregion
-export { EggAlwaysNewObjectContainer };

package/dist/impl/EggObjectImpl.d.ts

@@ -1,21 +0,0 @@
-import { EggObject, EggObjectLifeCycleContext, EggObjectName, EggPrototype } from "@eggjs/tegg-types";
-
-//#region src/impl/EggObjectImpl.d.ts
-declare class EggObjectImpl implements EggObject {
-  private _obj;
-  private status;
-  readonly proto: EggPrototype;
-  readonly name: EggObjectName;
-  readonly id: string;
-  constructor(name: EggObjectName, proto: EggPrototype);
-  initWithInjectProperty(ctx: EggObjectLifeCycleContext): Promise<void>;
-  initWithInjectConstructor(ctx: EggObjectLifeCycleContext): Promise<void>;
-  init(ctx: EggObjectLifeCycleContext): Promise<void>;
-  destroy(ctx: EggObjectLifeCycleContext): Promise<void>;
-  injectProperty(name: EggObjectName, descriptor: PropertyDescriptor): void;
-  get obj(): object;
-  get isReady(): boolean;
-  static createObject(name: EggObjectName, proto: EggPrototype, lifecycleContext: EggObjectLifeCycleContext): Promise<EggObjectImpl>;
-}
-//#endregion
-export { EggObjectImpl };

package/dist/impl/EggObjectImpl.js

@@ -1,126 +0,0 @@
-import { EggContainerFactory } from "../factory/EggContainerFactory.js";
-import { EggObjectUtil } from "./EggObjectUtil.js";
-import "../factory/index.js";
-import { ContextHandler } from "../model/ContextHandler.js";
-import { EggObjectLifecycleUtil } from "../model/EggObject.js";
-import "../model/index.js";
-import { EggObjectStatus, InjectType, ObjectInitType } from "@eggjs/tegg-types";
-import { LoadUnitFactory } from "@eggjs/tegg-metadata";
-import { IdenticalUtil } from "@eggjs/tegg-lifecycle";
-
-//#region src/impl/EggObjectImpl.ts
-var EggObjectImpl = class EggObjectImpl {
-	_obj;
-	status = EggObjectStatus.PENDING;
-	proto;
-	name;
-	id;
-	constructor(name, proto) {
-		this.name = name;
-		this.proto = proto;
-		const ctx = ContextHandler.getContext();
-		this.id = IdenticalUtil.createObjectId(this.proto.id, ctx?.id);
-	}
-	async initWithInjectProperty(ctx) {
-		try {
-			this._obj = this.proto.constructEggObject();
-			const objLifecycleHook = this._obj;
-			await EggObjectLifecycleUtil.objectPreCreate(ctx, this);
-			const postConstructMethod = EggObjectLifecycleUtil.getLifecycleHook("postConstruct", this.proto) ?? "postConstruct";
-			if (objLifecycleHook[postConstructMethod]) await objLifecycleHook[postConstructMethod](ctx, this);
-			const preInjectMethod = EggObjectLifecycleUtil.getLifecycleHook("preInject", this.proto) ?? "preInject";
-			if (objLifecycleHook[preInjectMethod]) await objLifecycleHook[preInjectMethod](ctx, this);
-			await Promise.all(this.proto.injectObjects.map(async (injectObject) => {
-				const proto = injectObject.proto;
-				if (!LoadUnitFactory.getLoadUnitById(proto.loadUnitId)) throw new Error(`can not find load unit: ${proto.loadUnitId}`);
-				if (this.proto.initType !== ObjectInitType.CONTEXT && injectObject.proto.initType === ObjectInitType.CONTEXT) this.injectProperty(injectObject.refName, EggObjectUtil.contextEggObjectGetProperty(proto, injectObject.objName));
-				else {
-					const injectObj = await EggContainerFactory.getOrCreateEggObject(proto, injectObject.objName);
-					this.injectProperty(injectObject.refName, EggObjectUtil.eggObjectGetProperty(injectObj));
-				}
-			}));
-			await EggObjectLifecycleUtil.objectPostCreate(ctx, this);
-			const postInjectMethod = EggObjectLifecycleUtil.getLifecycleHook("postInject", this.proto) ?? "postInject";
-			if (objLifecycleHook[postInjectMethod]) await objLifecycleHook[postInjectMethod](ctx, this);
-			const initMethod = EggObjectLifecycleUtil.getLifecycleHook("init", this.proto) ?? "init";
-			if (objLifecycleHook[initMethod]) await objLifecycleHook[initMethod](ctx, this);
-			this.status = EggObjectStatus.READY;
-		} catch (e) {
-			this.status = EggObjectStatus.ERROR;
-			throw e;
-		}
-	}
-	async initWithInjectConstructor(ctx) {
-		try {
-			const constructArgs = await Promise.all(this.proto.injectObjects.map(async (injectObject) => {
-				const proto = injectObject.proto;
-				if (!LoadUnitFactory.getLoadUnitById(proto.loadUnitId)) throw new Error(`can not find load unit: ${proto.loadUnitId}`);
-				if (this.proto.initType !== ObjectInitType.CONTEXT && injectObject.proto.initType === ObjectInitType.CONTEXT) return EggObjectUtil.contextEggObjectProxy(proto, injectObject.objName);
-				const injectObj = await EggContainerFactory.getOrCreateEggObject(proto, injectObject.objName);
-				return EggObjectUtil.eggObjectProxy(injectObj);
-			}));
-			if (typeof this.proto.multiInstanceConstructorIndex !== "undefined") {
-				const qualifiers = this.proto.multiInstanceConstructorAttributes?.map((t) => {
-					return {
-						attribute: t,
-						value: this.proto.getQualifier(t)
-					};
-				})?.filter((t) => typeof t.value !== "undefined") ?? [];
-				const objInfo = {
-					name: this.proto.name,
-					qualifiers
-				};
-				constructArgs.splice(this.proto.multiInstanceConstructorIndex, 0, objInfo);
-			}
-			this._obj = this.proto.constructEggObject(...constructArgs);
-			const objLifecycleHook = this._obj;
-			await EggObjectLifecycleUtil.objectPreCreate(ctx, this);
-			const postConstructMethod = EggObjectLifecycleUtil.getLifecycleHook("postConstruct", this.proto) ?? "postConstruct";
-			if (objLifecycleHook[postConstructMethod]) await objLifecycleHook[postConstructMethod](ctx, this);
-			const preInjectMethod = EggObjectLifecycleUtil.getLifecycleHook("preInject", this.proto) ?? "preInject";
-			if (objLifecycleHook[preInjectMethod]) await objLifecycleHook[preInjectMethod](ctx, this);
-			await EggObjectLifecycleUtil.objectPostCreate(ctx, this);
-			const postInjectMethod = EggObjectLifecycleUtil.getLifecycleHook("postInject", this.proto) ?? "postInject";
-			if (objLifecycleHook[postInjectMethod]) await objLifecycleHook[postInjectMethod](ctx, this);
-			const initMethod = EggObjectLifecycleUtil.getLifecycleHook("init", this.proto) ?? "init";
-			if (objLifecycleHook[initMethod]) await objLifecycleHook[initMethod](ctx, this);
-			this.status = EggObjectStatus.READY;
-		} catch (e) {
-			this.status = EggObjectStatus.ERROR;
-			throw e;
-		}
-	}
-	async init(ctx) {
-		if (this.proto.injectType === InjectType.CONSTRUCTOR) await this.initWithInjectConstructor(ctx);
-		else await this.initWithInjectProperty(ctx);
-	}
-	async destroy(ctx) {
-		if (this.status === EggObjectStatus.READY) {
-			this.status = EggObjectStatus.DESTROYING;
-			await EggObjectLifecycleUtil.objectPreDestroy(ctx, this);
-			const objLifecycleHook = this._obj;
-			const preDestroyMethod = EggObjectLifecycleUtil.getLifecycleHook("preDestroy", this.proto) ?? "preDestroy";
-			if (objLifecycleHook[preDestroyMethod]) await objLifecycleHook[preDestroyMethod](ctx, this);
-			const destroyMethod = EggObjectLifecycleUtil.getLifecycleHook("destroy", this.proto) ?? "destroy";
-			if (objLifecycleHook[destroyMethod]) await objLifecycleHook[destroyMethod](ctx, this);
-			this.status = EggObjectStatus.DESTROYED;
-		}
-	}
-	injectProperty(name, descriptor) {
-		Reflect.defineProperty(this._obj, name, descriptor);
-	}
-	get obj() {
-		return this._obj;
-	}
-	get isReady() {
-		return this.status === EggObjectStatus.READY;
-	}
-	static async createObject(name, proto, lifecycleContext) {
-		const obj = new EggObjectImpl(name, proto);
-		await obj.init(lifecycleContext);
-		return obj;
-	}
-};
-
-//#endregion
-export { EggObjectImpl };

package/dist/impl/EggObjectUtil.d.ts

@@ -1,11 +0,0 @@
-import { EggObject, EggPrototype } from "@eggjs/tegg-types";
-
-//#region src/impl/EggObjectUtil.d.ts
-declare class EggObjectUtil {
-  static eggObjectGetProperty(eggObject: EggObject): PropertyDescriptor;
-  static contextEggObjectGetProperty(proto: EggPrototype, objName: PropertyKey): PropertyDescriptor;
-  static eggObjectProxy(eggObject: EggObject): PropertyDescriptor;
-  static contextEggObjectProxy(proto: EggPrototype, objName: PropertyKey): PropertyDescriptor;
-}
-//#endregion
-export { EggObjectUtil };

package/dist/impl/EggObjectUtil.js

@@ -1,147 +0,0 @@
-import { EggContainerFactory } from "../factory/EggContainerFactory.js";
-import "../factory/index.js";
-
-//#region src/impl/EggObjectUtil.ts
-var EggObjectUtil = class {
-	static eggObjectGetProperty(eggObject) {
-		return {
-			get() {
-				return eggObject.obj;
-			},
-			configurable: true,
-			enumerable: true
-		};
-	}
-	static contextEggObjectGetProperty(proto, objName) {
-		const PROTO_OBJ_GETTER = Symbol(`EggPrototype#objGetter#${String(objName)}`);
-		if (!proto[PROTO_OBJ_GETTER]) proto[PROTO_OBJ_GETTER] = {
-			get() {
-				return EggContainerFactory.getEggObject(proto, objName).obj;
-			},
-			configurable: true,
-			enumerable: true
-		};
-		return proto[PROTO_OBJ_GETTER];
-	}
-	static eggObjectProxy(eggObject) {
-		let _obj;
-		function getObj() {
-			if (!_obj) _obj = eggObject.obj;
-			return _obj;
-		}
-		return new Proxy({}, {
-			defineProperty(_target, property, attributes) {
-				const obj = getObj();
-				Object.defineProperty(obj, property, attributes);
-				return true;
-			},
-			deleteProperty(_target, p) {
-				const obj = getObj();
-				delete obj[p];
-				return true;
-			},
-			get(target, p) {
-				if (p === "then") return;
-				if (Object.prototype[p]) return target[p];
-				const obj = getObj();
-				const val = obj[p];
-				if (typeof val === "function") return val.bind(obj);
-				return val;
-			},
-			getOwnPropertyDescriptor(_target, p) {
-				const obj = getObj();
-				return Object.getOwnPropertyDescriptor(obj, p);
-			},
-			getPrototypeOf() {
-				const obj = getObj();
-				return Object.getPrototypeOf(obj);
-			},
-			has(_target, p) {
-				const obj = getObj();
-				return p in obj;
-			},
-			isExtensible() {
-				const obj = getObj();
-				return Object.isExtensible(obj);
-			},
-			ownKeys() {
-				const obj = getObj();
-				return Reflect.ownKeys(obj);
-			},
-			preventExtensions() {
-				const obj = getObj();
-				Object.preventExtensions(obj);
-				return true;
-			},
-			set(_target, p, newValue) {
-				const obj = getObj();
-				obj[p] = newValue;
-				return true;
-			},
-			setPrototypeOf(_target, v) {
-				const obj = getObj();
-				Object.setPrototypeOf(obj, v);
-				return true;
-			}
-		});
-	}
-	static contextEggObjectProxy(proto, objName) {
-		const PROTO_OBJ_PROXY = Symbol(`EggPrototype#objProxy#${String(objName)}`);
-		if (!proto[PROTO_OBJ_PROXY]) proto[PROTO_OBJ_PROXY] = new Proxy({}, {
-			defineProperty(_target, property, attributes) {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				Object.defineProperty(obj, property, attributes);
-				return true;
-			},
-			deleteProperty(_target, p) {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				delete obj[p];
-				return true;
-			},
-			get(target, p) {
-				if (p === "then") return;
-				if (Object.prototype[p]) return target[p];
-				return EggContainerFactory.getEggObject(proto, objName).obj[p];
-			},
-			getOwnPropertyDescriptor(_target, p) {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				return Object.getOwnPropertyDescriptor(obj, p);
-			},
-			getPrototypeOf() {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				return Object.getPrototypeOf(obj);
-			},
-			has(_target, p) {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				return p in obj;
-			},
-			isExtensible() {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				return Object.isExtensible(obj);
-			},
-			ownKeys() {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				return Reflect.ownKeys(obj);
-			},
-			preventExtensions() {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				Object.preventExtensions(obj);
-				return true;
-			},
-			set(_target, p, newValue) {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				obj[p] = newValue;
-				return true;
-			},
-			setPrototypeOf(_target, v) {
-				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
-				Object.setPrototypeOf(obj, v);
-				return true;
-			}
-		});
-		return proto[PROTO_OBJ_PROXY];
-	}
-};
-
-//#endregion
-export { EggObjectUtil };

package/dist/impl/ModuleLoadUnitInstance.d.ts

@@ -1,22 +0,0 @@
-import { EggObject, EggObjectName, EggPrototype, EggPrototypeName, LoadUnit, LoadUnitInstance, LoadUnitInstanceLifecycleContext } from "@eggjs/tegg-types";
-
-//#region src/impl/ModuleLoadUnitInstance.d.ts
-declare class ModuleLoadUnitInstance implements LoadUnitInstance {
-  readonly loadUnit: LoadUnit;
-  readonly id: string;
-  readonly name: string;
-  private protoToCreateMap;
-  private eggObjectMap;
-  private eggObjectPromiseMap;
-  constructor(loadUnit: LoadUnit);
-  iterateProtoToCreate(): IterableIterator<[EggObjectName, EggPrototype]>;
-  addProtoToCreate(name: string, proto: EggPrototype): void;
-  deleteProtoToCreate(name: string): void;
-  init(ctx: LoadUnitInstanceLifecycleContext): Promise<void>;
-  destroy(): Promise<void>;
-  getOrCreateEggObject(name: EggPrototypeName, proto: EggPrototype): Promise<EggObject>;
-  getEggObject(name: EggPrototypeName, proto: EggPrototype): EggObject;
-  static createModuleLoadUnitInstance(ctx: LoadUnitInstanceLifecycleContext): LoadUnitInstance;
-}
-//#endregion
-export { ModuleLoadUnitInstance };

package/dist/impl/ModuleLoadUnitInstance.js

@@ -1,73 +0,0 @@
-import { LoadUnitInstanceLifecycleUtil } from "../model/LoadUnitInstance.js";
-import { LoadUnitInstanceFactory } from "../factory/LoadUnitInstanceFactory.js";
-import { EggObjectFactory } from "../factory/EggObjectFactory.js";
-import { EggLoadUnitType, ObjectInitType } from "@eggjs/tegg-types";
-import { MapUtil } from "@eggjs/tegg-common-util";
-import { IdenticalUtil } from "@eggjs/tegg-lifecycle";
-
-//#region src/impl/ModuleLoadUnitInstance.ts
-var ModuleLoadUnitInstance = class ModuleLoadUnitInstance {
-	loadUnit;
-	id;
-	name;
-	protoToCreateMap = [];
-	eggObjectMap = /* @__PURE__ */ new Map();
-	eggObjectPromiseMap = /* @__PURE__ */ new Map();
-	constructor(loadUnit) {
-		this.loadUnit = loadUnit;
-		this.name = loadUnit.name;
-		const iterator = this.loadUnit.iterateEggPrototype();
-		for (const proto of iterator) if (proto.initType === ObjectInitType.SINGLETON) this.protoToCreateMap.push([proto.name, proto]);
-		this.id = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
-	}
-	iterateProtoToCreate() {
-		return this.protoToCreateMap[Symbol.iterator]();
-	}
-	addProtoToCreate(name, proto) {
-		this.protoToCreateMap.push([name, proto]);
-	}
-	deleteProtoToCreate(name) {
-		const index = this.protoToCreateMap.findIndex(([protoName]) => protoName === name);
-		if (index !== -1) this.protoToCreateMap.splice(index, 1);
-	}
-	async init(ctx) {
-		await LoadUnitInstanceLifecycleUtil.objectPreCreate(ctx, this);
-		for (const [name, proto] of this.protoToCreateMap) await this.getOrCreateEggObject(name, proto);
-		await LoadUnitInstanceLifecycleUtil.objectPostCreate(ctx, this);
-	}
-	async destroy() {
-		const objs = [];
-		for (const protoObjMap of this.eggObjectMap.values()) for (const obj of protoObjMap.values()) objs.push(obj);
-		this.eggObjectMap.clear();
-		await Promise.all(objs.map(async (obj) => {
-			await EggObjectFactory.destroyObject(obj);
-		}));
-	}
-	async getOrCreateEggObject(name, proto) {
-		if (!this.loadUnit.containPrototype(proto)) throw new Error("load unit not contain proto");
-		const protoObjMap = MapUtil.getOrStore(this.eggObjectMap, proto.id, /* @__PURE__ */ new Map());
-		if (!protoObjMap.has(name)) {
-			const protoObjPromiseMap = MapUtil.getOrStore(this.eggObjectPromiseMap, proto.id, /* @__PURE__ */ new Map());
-			if (!protoObjPromiseMap.has(name)) {
-				const objPromise = EggObjectFactory.createObject(name, proto);
-				protoObjPromiseMap.set(name, objPromise);
-				const obj = await objPromise;
-				protoObjPromiseMap.delete(name);
-				protoObjMap.set(name, obj);
-			} else await protoObjPromiseMap.get(name);
-		}
-		return protoObjMap.get(name);
-	}
-	getEggObject(name, proto) {
-		const protoObjMap = this.eggObjectMap.get(proto.id);
-		if (!protoObjMap || !protoObjMap.has(name)) throw new Error(`EggObject ${String(proto.name)} not found`);
-		return protoObjMap.get(name);
-	}
-	static createModuleLoadUnitInstance(ctx) {
-		return new ModuleLoadUnitInstance(ctx.loadUnit);
-	}
-};
-LoadUnitInstanceFactory.registerLoadUnitInstanceClass(EggLoadUnitType.MODULE, ModuleLoadUnitInstance.createModuleLoadUnitInstance);
-
-//#endregion
-export { ModuleLoadUnitInstance };

package/dist/impl/index.js

@@ -1,8 +0,0 @@
-import { ContextObjectGraph } from "./ContextObjectGraph.js";
-import { ContextInitiator } from "./ContextInitiator.js";
-import { EggAlwaysNewObjectContainer } from "./EggAlwaysNewObjectContainer.js";
-import { EggObjectUtil } from "./EggObjectUtil.js";
-import { EggObjectImpl } from "./EggObjectImpl.js";
-import { ModuleLoadUnitInstance } from "./ModuleLoadUnitInstance.js";
-
-export {  };

package/dist/model/AbstractEggContext.d.ts

@@ -1,22 +0,0 @@
-import { EggContextLifecycleContext, EggObject, EggObjectName, EggPrototype, EggPrototypeName, EggRuntimeContext } from "@eggjs/tegg-types";
-
-//#region src/model/AbstractEggContext.d.ts
-declare abstract class AbstractEggContext implements EggRuntimeContext {
-  private contextData;
-  private protoToCreate;
-  private eggObjectMap;
-  private eggObjectPromiseMap;
-  private destroyed;
-  abstract id: string;
-  addProtoToCreate(name: string, proto: EggPrototype): void;
-  deleteProtoToCreate(name: string): void;
-  destroy(ctx: EggContextLifecycleContext): Promise<void>;
-  get(key: string | symbol): any | undefined;
-  getEggObject(name: EggPrototypeName, proto: EggPrototype): EggObject;
-  getOrCreateEggObject(name: EggPrototypeName, proto: EggPrototype): Promise<EggObject>;
-  init(ctx: EggContextLifecycleContext): Promise<void>;
-  iterateProtoToCreate(): IterableIterator<[EggObjectName, EggPrototype]>;
-  set(key: string | symbol, val: any): void;
-}
-//#endregion
-export { AbstractEggContext };