@eggjs/tegg-plugin 4.0.0-beta.8 → 4.0.1-beta.0

package/dist/lib/ModuleHandler.d.ts

@@ -1,2 +1,18 @@
-import { ModuleHandler } from "../ModuleHandler-Dyx7JGj-.js";
+import { GlobalGraphBuildHook, LoadUnit } from "@eggjs/metadata";
+import { LoadUnitInstance } from "@eggjs/tegg-runtime";
+import { Base } from "sdk-base";
+import { Application } from "egg";
+
+//#region src/lib/ModuleHandler.d.ts
+declare class ModuleHandler extends Base {
+  loadUnits: LoadUnit[];
+  loadUnitInstances: LoadUnitInstance[];
+  private readonly loadUnitLoader;
+  private readonly app;
+  constructor(app: Application);
+  registerGlobalGraphBuildHook(hook: GlobalGraphBuildHook): void;
+  init(): Promise<void>;
+  destroy(): Promise<void>;
+}
+//#endregion
 export { ModuleHandler };

package/dist/lib/ModuleHandler.js

@@ -1,8 +1,48 @@
-import "../EggCompatibleProtoImpl-CPxLvSu4.js";
-import "../ModuleConfigLoader-CvZLf99E.js";
-import "../EggAppLoader-DFYg65ry.js";
-import "../EggModuleLoader-CCfQMmp5.js";
-import "../CompatibleUtil-CNhydb0E.js";
-import { ModuleHandler } from "../ModuleHandler-fKcUqWca.js";
+import { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl.js";
+import { CompatibleUtil } from "./CompatibleUtil.js";
+import { EggModuleLoader } from "./EggModuleLoader.js";
+import { EggLoadUnitType, LoadUnitFactory } from "@eggjs/metadata";
+import { LoadUnitInstanceFactory } from "@eggjs/tegg-runtime";
+import { Base } from "sdk-base";
 
+//#region src/lib/ModuleHandler.ts
+var ModuleHandler = class extends Base {
+	loadUnits = [];
+	loadUnitInstances = [];
+	loadUnitLoader;
+	app;
+	constructor(app) {
+		super();
+		this.app = app;
+		this.loadUnitLoader = new EggModuleLoader(this.app);
+	}
+	registerGlobalGraphBuildHook(hook) {
+		this.loadUnitLoader.registerBuildHook(hook);
+	}
+	async init() {
+		try {
+			this.app.eggPrototypeCreatorFactory.registerPrototypeCreator(COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl.create);
+			await this.loadUnitLoader.load();
+			const instances = [];
+			this.app.module = {};
+			for (const loadUnit of this.loadUnits) {
+				const instance = await LoadUnitInstanceFactory.createLoadUnitInstance(loadUnit);
+				if (instance.loadUnit.type !== EggLoadUnitType.APP) CompatibleUtil.appCompatible(this.app, instance);
+				instances.push(instance);
+			}
+			CompatibleUtil.contextModuleCompatible(this.app.context, instances);
+			this.loadUnitInstances = instances;
+			this.ready(true);
+		} catch (e) {
+			this.ready(e);
+			throw e;
+		}
+	}
+	async destroy() {
+		if (this.loadUnitInstances) for (const instance of this.loadUnitInstances) await LoadUnitInstanceFactory.destroyLoadUnitInstance(instance);
+		if (this.loadUnits) for (const loadUnit of this.loadUnits) await LoadUnitFactory.destroyLoadUnit(loadUnit);
+	}
+};
+
+//#endregion
 export { ModuleHandler };

package/dist/lib/Utils.d.ts

@@ -1,4 +1,4 @@
 //#region src/lib/Utils.d.ts
-declare function getCalleeFromStack(withLine: boolean, stackIndex?: number): any;
+declare function getCalleeFromStack(withLine: boolean, stackIndex?: number): string;
 //#endregion
 export { getCalleeFromStack };

package/dist/lib/Utils.js

@@ -1,3 +1,33 @@
-import { getCalleeFromStack } from "../Utils-11aRpnkd.js";
+//#region src/lib/Utils.ts
+function prepareObjectStackTrace(_, stack) {
+	return stack;
+}
+function getCalleeFromStack(withLine, stackIndex) {
+	stackIndex = stackIndex === void 0 ? 2 : stackIndex;
+	const limit = Error.stackTraceLimit;
+	const prep = Error.prepareStackTrace;
+	Error.prepareStackTrace = prepareObjectStackTrace;
+	Error.stackTraceLimit = 5;
+	const obj = {};
+	Error.captureStackTrace(obj);
+	let callSite = obj.stack[stackIndex];
+	let fileName;
+	/* istanbul ignore else */
+	if (callSite) {
+		fileName = callSite.getFileName();
+		/* istanbul ignore if */
+		if (fileName && fileName.endsWith("egg-mock/lib/app.js")) {
+			callSite = obj.stack[stackIndex + 1];
+			fileName = callSite.getFileName();
+		}
+	}
+	Error.prepareStackTrace = prep;
+	Error.stackTraceLimit = limit;
+	/* istanbul ignore if */
+	if (!callSite || !fileName) return "<anonymous>";
+	if (!withLine) return fileName;
+	return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
+}
 
+//#endregion
 export { getCalleeFromStack };

package/dist/lib/ctx_lifecycle_middleware.d.ts

@@ -1,2 +1,6 @@
-import { ctxLifecycleMiddleware } from "../ctx_lifecycle_middleware-DV7uN5PG.js";
+import { Context, Next } from "egg";
+
+//#region src/lib/ctx_lifecycle_middleware.d.ts
+declare function ctxLifecycleMiddleware(ctx: Context, next: Next): Promise<void>;
+//#endregion
 export { ctxLifecycleMiddleware };

package/dist/lib/ctx_lifecycle_middleware.js

@@ -1,4 +1,38 @@
-import "../EggContextImpl-DkCLPTzT.js";
-import { ctxLifecycleMiddleware } from "../ctx_lifecycle_middleware-CIeSrbVY.js";
+import { EggContextImpl } from "./EggContextImpl.js";
+import { StreamUtil } from "@eggjs/tegg-common-util";
+import { ROOT_PROTO, TEGG_CONTEXT } from "@eggjs/module-common";
+import awaitFirst from "await-first";
 
+//#region src/lib/ctx_lifecycle_middleware.ts
+async function ctxLifecycleMiddleware(ctx, next) {
+	if (ctx[TEGG_CONTEXT]) {
+		await next();
+		return;
+	}
+	const lifecycleCtx = {};
+	const teggCtx = new EggContextImpl(ctx);
+	const rootProto = ctx[ROOT_PROTO];
+	if (rootProto) teggCtx.set(ROOT_PROTO, rootProto);
+	if (teggCtx.init) await teggCtx.init(lifecycleCtx);
+	async function doDestroy() {
+		if (StreamUtil.isStream(ctx.response.body)) try {
+			await awaitFirst(ctx.response.body, ["close", "error"]);
+		} catch (error) {
+			ctx.res.destroy(error);
+		}
+		try {
+			if (teggCtx.destroy) await teggCtx.destroy(lifecycleCtx);
+		} catch (e) {
+			e.message = `[tegg/ctxLifecycleMiddleware] destroy tegg ctx failed: ${e.message}`;
+			ctx.logger.error(e);
+		}
+	}
+	try {
+		await next();
+	} finally {
+		doDestroy();
+	}
+}
+
+//#endregion
 export { ctxLifecycleMiddleware };

package/dist/lib/run_in_background.js

@@ -1,7 +1,50 @@
-import "../EggContextImpl-DkCLPTzT.js";
-import "../ctx_lifecycle_middleware-CIeSrbVY.js";
-import "../context-BWYE1dif.js";
-import "../Utils-11aRpnkd.js";
-import { LONG_STACK_DELIMITER, hijackRunInBackground } from "../run_in_background-CEUPBmDB.js";
+import { getCalleeFromStack } from "./Utils.js";
+import { PrototypeUtil } from "@eggjs/core-decorator";
+import { BackgroundTaskHelper } from "@eggjs/background-task";
+import { TEGG_CONTEXT } from "@eggjs/module-common";
 
+//#region src/lib/run_in_background.ts
+const LONG_STACK_DELIMITER = "\n --------------------\n";
+function addLongStackTrace(err, causeError) {
+	const callSiteStack = causeError.stack;
+	if (!callSiteStack || typeof callSiteStack !== "string") return;
+	const index = callSiteStack.indexOf("\n");
+	if (index !== -1) err.stack += LONG_STACK_DELIMITER + callSiteStack.substring(index + 1);
+}
+function hijackRunInBackground(app) {
+	const eggRunInBackground = app.context.runInBackground;
+	app.context.runInBackground = function runInBackground(scope) {
+		if (!this[TEGG_CONTEXT]) return Reflect.apply(eggRunInBackground, this, [scope]);
+		const caseError = /* @__PURE__ */ new Error("cause");
+		let resolveBackgroundTask;
+		const backgroundTaskPromise = new Promise((resolve) => {
+			resolveBackgroundTask = resolve;
+		});
+		const newScope = async () => {
+			try {
+				await scope(this);
+			} catch (e) {
+				addLongStackTrace(e, caseError);
+				throw e;
+			} finally {
+				resolveBackgroundTask();
+			}
+		};
+		const taskName = scope._name || scope.name || getCalleeFromStack(true, 2);
+		scope._name = taskName;
+		Object.defineProperty(newScope, "name", {
+			value: taskName,
+			enumerable: false,
+			configurable: true,
+			writable: false
+		});
+		Reflect.apply(eggRunInBackground, this, [newScope]);
+		const proto = PrototypeUtil.getClazzProto(BackgroundTaskHelper);
+		app.eggContainerFactory.getEggObject(proto).obj.run(async () => {
+			await backgroundTaskPromise;
+		});
+	};
+}
+
+//#endregion
 export { LONG_STACK_DELIMITER, hijackRunInBackground };

package/dist/types.d.ts

@@ -1,6 +1,54 @@
-import "./ModuleHandler-Dyx7JGj-.js";
-import "./EggContextHandler-vGi67He5.js";
-import "./application-Ccljinuy.js";
-import "./application.unittest-CpoCu6-E.js";
-import "./context-BoIt2G5h.js";
-import "./types-CuoKQV4X.js";
+import { EggContextHandler } from "./lib/EggContextHandler.js";
+import { ModuleHandler } from "./lib/ModuleHandler.js";
+import { QualifierInfo } from "@eggjs/core-decorator";
+import { IdenticalUtil } from "@eggjs/lifecycle";
+import { EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from "@eggjs/metadata";
+import { AbstractEggContext, EggContainerFactory, EggContext, EggContextLifecycleUtil, EggObjectFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+import "@eggjs/tegg-config/types";
+
+//#region src/types.d.ts
+declare module "egg" {
+  interface EggModule {}
+  interface Application {
+    eggPrototypeCreatorFactory: typeof EggPrototypeCreatorFactory;
+    eggPrototypeFactory: EggPrototypeFactory;
+    eggContainerFactory: typeof EggContainerFactory;
+    loadUnitFactory: typeof LoadUnitFactory;
+    eggObjectFactory: typeof EggObjectFactory;
+    loadUnitInstanceFactory: typeof LoadUnitInstanceFactory;
+    abstractEggContext: typeof AbstractEggContext;
+    identicalUtil: typeof IdenticalUtil;
+    loaderFactory: typeof LoaderFactory;
+    loadUnitLifecycleUtil: typeof LoadUnitLifecycleUtil;
+    loadUnitInstanceLifecycleUtil: typeof LoadUnitInstanceLifecycleUtil;
+    eggPrototypeLifecycleUtil: typeof EggPrototypeLifecycleUtil;
+    eggContextLifecycleUtil: typeof EggContextLifecycleUtil;
+    eggObjectLifecycleUtil: typeof EggObjectLifecycleUtil;
+    teggContext: EggContext;
+    moduleHandler: ModuleHandler;
+    eggContextHandler: EggContextHandler;
+    getEggObject<T>(clazz: new (...args: any[]) => T, name?: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+    getEggObjectFromName<T extends object>(name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+    module: EggModule;
+    /**
+    * Mock the module context, only for unittest
+    */
+    mockModuleContext(data?: any): Promise<Context>;
+    /**
+    * Mock the module context scope, only for unittest
+    */
+    mockModuleContextScope<R = any>(fn: (ctx: Context) => Promise<R>, data?: any): Promise<R>;
+    /**
+    * Destroy the module context, only for unittest
+    */
+    destroyModuleContext(context: Context): Promise<void>;
+  }
+  interface Context {
+    beginModuleScope(func: () => Promise<void>): Promise<void>;
+    getEggObject<T>(clazz: new (...args: any[]) => T, name?: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+    getEggObjectFromName<T>(name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+    teggContext: EggContext;
+    module: EggModule;
+  }
+}

package/dist/types.js

@@ -1,15 +1,3 @@
-import "./EggCompatibleProtoImpl-CPxLvSu4.js";
-import "./ModuleConfigLoader-CvZLf99E.js";
-import "./EggAppLoader-DFYg65ry.js";
-import "./EggModuleLoader-CCfQMmp5.js";
-import "./CompatibleUtil-CNhydb0E.js";
-import "./ModuleHandler-fKcUqWca.js";
-import "./EggContextHandler-D8gfTbZs.js";
-import "./EggContextImpl-DkCLPTzT.js";
-import "./ctx_lifecycle_middleware-CIeSrbVY.js";
-import "./context-BWYE1dif.js";
-import "./application-DFI1junS.js";
-import "./application.unittest-Cmia71Fx.js";
-import "./types-BHg5p4Xk.js";
+import "@eggjs/tegg-config/types";
 
 export {  };

package/package.json

@@ -1,24 +1,30 @@
 {
   "name": "@eggjs/tegg-plugin",
-  "eggPlugin": {
-    "name": "tegg",
-    "dependencies": [
-      "teggConfig"
-    ]
-  },
-  "version": "4.0.0-beta.8",
+  "version": "4.0.1-beta.0",
   "description": "module plugin for egg",
   "keywords": [
     "egg",
-    "plugin",
-    "typescript",
     "module",
-    "tegg"
+    "plugin",
+    "tegg",
+    "typescript"
   ],
+  "homepage": "https://github.com/eggjs/egg/tree/next/tegg/plugin/tegg",
+  "bugs": {
+    "url": "https://github.com/eggjs/egg/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eggjs/egg.git",
+    "directory": "tegg/plugin/tegg"
+  },
   "files": [
     "dist"
   ],
   "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
     "./app": "./dist/app.js",
@@ -46,59 +52,48 @@
     "./types": "./dist/types.js",
     "./package.json": "./package.json"
   },
-  "homepage": "https://github.com/eggjs/tegg/tree/next/plugin/tegg",
-  "bugs": {
-    "url": "https://github.com/eggjs/tegg/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:eggjs/tegg.git",
-    "directory": "plugin/tegg"
-  },
-  "engines": {
-    "node": ">=22.18.0"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
+    "await-first": "^1.0.0",
     "extend2": "^4.0.0",
     "sdk-base": "^5.0.1",
-    "@eggjs/tegg": "4.0.0-beta.8",
-    "@eggjs/tegg-background-task": "4.0.0-beta.8",
-    "@eggjs/tegg-common-util": "4.0.0-beta.8",
-    "@eggjs/tegg-dynamic-inject-runtime": "4.0.0-beta.8",
-    "@eggjs/tegg-loader": "4.0.0-beta.8",
-    "@eggjs/egg-module-common": "4.0.0-beta.8",
-    "@eggjs/tegg-runtime": "4.0.0-beta.8",
-    "@eggjs/tegg-metadata": "4.0.0-beta.8"
-  },
-  "peerDependencies": {
-    "egg": "beta",
-    "@eggjs/tegg-config": "4.0.0-beta.8"
+    "@eggjs/background-task": "4.0.1-beta.0",
+    "@eggjs/core-decorator": "4.0.1-beta.0",
+    "@eggjs/lifecycle": "4.0.1-beta.0",
+    "@eggjs/dynamic-inject-runtime": "4.0.1-beta.0",
+    "@eggjs/metadata": "4.0.1-beta.0",
+    "@eggjs/module-common": "4.0.1-beta.0",
+    "@eggjs/tegg-loader": "4.0.1-beta.0",
+    "@eggjs/tegg-common-util": "4.0.1-beta.0",
+    "@eggjs/tegg-runtime": "4.0.1-beta.0",
+    "@eggjs/tegg-types": "4.0.1-beta.0"
   },
   "devDependencies": {
-    "@eggjs/bin": "beta",
-    "@eggjs/mock": "beta",
-    "@eggjs/tracer": "beta",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^22.10.5",
-    "egg": "beta",
-    "egg-logger": "^3.0.1",
-    "mocha": "^11.0.1",
+    "@types/node": "^24.10.2",
+    "egg-logger": "^3.5.0",
     "typescript": "^5.9.3",
-    "tsdown": "^0.15.6",
-    "unplugin-unused": "^0.5.3",
-    "@eggjs/tegg-config": "4.0.0-beta.8"
+    "@eggjs/tegg": "4.0.1-beta.0",
+    "@eggjs/tracer": "4.0.1-beta.0",
+    "@eggjs/tegg-config": "4.0.1-beta.0",
+    "egg": "4.1.1-beta.0",
+    "@eggjs/mock": "7.0.1-beta.0"
   },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "@eggjs/tegg-config": "4.0.1-beta.0",
+    "egg": "4.1.1-beta.0"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "eggPlugin": {
+    "name": "tegg",
+    "dependencies": [
+      "teggConfig"
+    ]
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "scripts": {
-    "typecheck": "tsc --noEmit",
-    "test:mocha": "egg-bin test",
-    "cov:mocha": "egg-bin cov",
-    "clean": "rimraf dist",
-    "build": "tsdown"
+    "typecheck": "tsgo --noEmit"
   }
 }

package/dist/AppLoadUnit-BOWdS4O9.d.ts

@@ -1,23 +0,0 @@
-import { EggLoadUnitTypeLike, EggPrototype, LoadUnit, LoadUnitLifecycleContext, Loader } from "@eggjs/tegg-metadata";
-import { Id, QualifierInfo } from "@eggjs/tegg";
-
-//#region src/lib/AppLoadUnit.d.ts
-declare class AppLoadUnit implements LoadUnit {
-  private readonly loader;
-  id: Id;
-  readonly name: string;
-  readonly type: EggLoadUnitTypeLike;
-  readonly unitPath: string;
-  private protoMap;
-  constructor(name: string, unitPath: string, loader: Loader);
-  init(): Promise<void>;
-  containPrototype(proto: EggPrototype): boolean;
-  getEggPrototype(name: string, qualifiers: QualifierInfo[]): EggPrototype[];
-  registerEggPrototype(proto: EggPrototype): void;
-  deletePrototype(proto: EggPrototype): void;
-  destroy(): Promise<void>;
-  iterateEggPrototype(): IterableIterator<EggPrototype>;
-  static createModule(ctx: LoadUnitLifecycleContext): AppLoadUnit;
-}
-//#endregion
-export { AppLoadUnit };

package/dist/AppLoadUnit-uyHgElRL.js

@@ -1,78 +0,0 @@
-import { debuglog } from "node:util";
-import { EggLoadUnitType, EggPrototypeCreatorFactory, EggPrototypeFactory, LoadUnitFactory } from "@eggjs/tegg-metadata";
-import { IdenticalUtil, InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
-import { MapUtil } from "@eggjs/tegg-common-util";
-
-//#region src/lib/AppLoadUnit.ts
-const debug = debuglog("tegg/plugin/tegg/lib/AppLoadUnit");
-var AppLoadUnit = class AppLoadUnit {
-	loader;
-	id;
-	name;
-	type = EggLoadUnitType.APP;
-	unitPath;
-	protoMap = /* @__PURE__ */ new Map();
-	constructor(name, unitPath, loader) {
-		this.id = IdenticalUtil.createLoadUnitId(name);
-		this.name = name;
-		this.unitPath = unitPath;
-		this.loader = loader;
-	}
-	async init() {
-		const clazzList = await this.loader.load();
-		if (debug.enabled) debug("init, get clazzList:%j, from unitPath:%o:%o:%o", clazzList.map((t) => t.name), this.type, this.name, this.unitPath);
-		for (const clazz of clazzList) {
-			const initTypeQualifierAttributeValue = await PrototypeUtil.getInitType(clazz, {
-				unitPath: this.unitPath,
-				moduleName: this.name
-			});
-			[{
-				attribute: InitTypeQualifierAttribute,
-				value: initTypeQualifierAttributeValue
-			}, {
-				attribute: LoadUnitNameQualifierAttribute,
-				value: this.name
-			}].forEach((qualifier) => {
-				QualifierUtil.addProtoQualifier(clazz, qualifier.attribute, qualifier.value);
-			});
-			const protos = await EggPrototypeCreatorFactory.createProto(clazz, this);
-			for (const proto of protos) EggPrototypeFactory.instance.registerPrototype(proto, this);
-		}
-	}
-	containPrototype(proto) {
-		return !!this.protoMap.get(proto.name)?.find((t) => t === proto);
-	}
-	getEggPrototype(name, qualifiers) {
-		return this.protoMap.get(name)?.filter((proto) => proto.verifyQualifiers(qualifiers)) || [];
-	}
-	registerEggPrototype(proto) {
-		MapUtil.getOrStore(this.protoMap, proto.name, []).push(proto);
-	}
-	deletePrototype(proto) {
-		const protos = this.protoMap.get(proto.name);
-		if (protos) {
-			const index = protos.indexOf(proto);
-			if (index !== -1) protos.splice(index, 1);
-		}
-	}
-	async destroy() {
-		for (const namedProtos of this.protoMap.values()) {
-			const protos = namedProtos.slice();
-			for (const proto of protos) EggPrototypeFactory.instance.deletePrototype(proto, this);
-		}
-		this.protoMap.clear();
-	}
-	iterateEggPrototype() {
-		return Array.from(this.protoMap.values()).reduce((p, c) => {
-			p = p.concat(c);
-			return p;
-		}, []).values();
-	}
-	static createModule(ctx) {
-		return new AppLoadUnit("tegg-app", ctx.unitPath, ctx.loader);
-	}
-};
-LoadUnitFactory.registerLoadUnitCreator(EggLoadUnitType.APP, AppLoadUnit.createModule);
-
-//#endregion
-export { AppLoadUnit };

package/dist/AppLoadUnitInstance-4Z_vSQV3.js

@@ -1,69 +0,0 @@
-import { EggLoadUnitType } from "@eggjs/tegg-metadata";
-import { IdenticalUtil, ObjectInitType } from "@eggjs/tegg";
-import { MapUtil } from "@eggjs/tegg-common-util";
-import { EggObjectFactory, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
-
-//#region src/lib/AppLoadUnitInstance.ts
-var AppLoadUnitInstance = class AppLoadUnitInstance {
-	loadUnit;
-	id;
-	name;
-	protoToCreateMap = /* @__PURE__ */ new Map();
-	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.set(proto.name, proto);
-		this.id = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
-	}
-	iterateProtoToCreate() {
-		return this.protoToCreateMap.entries();
-	}
-	addProtoToCreate(name, proto) {
-		this.protoToCreateMap.set(name, proto);
-	}
-	deleteProtoToCreate(name) {
-		this.protoToCreateMap.delete(name);
-	}
-	async init(ctx) {
-		await LoadUnitInstanceLifecycleUtil.objectPreCreate(ctx, this);
-		for (const [name, proto] of this.protoToCreateMap) await this.getOrCreateEggObject(name, proto);
-	}
-	async destroy() {
-		const objs = [];
-		for (const protoObjMap of this.eggObjectMap.values()) for (const protoObj of protoObjMap.values()) objs.push(protoObj);
-		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 AppLoadUnitInstance(ctx.loadUnit);
-	}
-};
-LoadUnitInstanceFactory.registerLoadUnitInstanceClass(EggLoadUnitType.APP, AppLoadUnitInstance.createModuleLoadUnitInstance);
-
-//#endregion
-export { AppLoadUnitInstance };

package/dist/AppLoadUnitInstance-DQ-DxlmR.d.ts

@@ -1,24 +0,0 @@
-import { EggPrototype, LoadUnit } from "@eggjs/tegg-metadata";
-import { EggObjectName, EggPrototypeName } from "@eggjs/tegg";
-import { EggObject, LoadUnitInstance, LoadUnitInstanceLifecycleContext } from "@eggjs/tegg-runtime";
-
-//#region src/lib/AppLoadUnitInstance.d.ts
-declare class AppLoadUnitInstance 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 { AppLoadUnitInstance };