@eggjs/tegg-plugin 4.0.0-beta.7 → 4.0.0-beta.8

package/dist/application-Ccljinuy.d.ts

@@ -0,0 +1,57 @@
+import { ModuleHandler } from "./ModuleHandler-Dyx7JGj-.js";
+import { EggContextHandler } from "./EggContextHandler-vGi67He5.js";
+import * as _eggjs_tegg_metadata0 from "@eggjs/tegg-metadata";
+import { EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from "@eggjs/tegg-metadata";
+import * as _eggjs_tegg0 from "@eggjs/tegg";
+import { EggProtoImplClass, IdenticalUtil, QualifierInfo, RuntimeConfig } from "@eggjs/tegg";
+import * as _eggjs_tegg_runtime0 from "@eggjs/tegg-runtime";
+import { AbstractEggContext, EggContainerFactory, EggContext, EggContextLifecycleUtil, EggObjectFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
+import { Application } from "egg";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+
+//#region src/app/extend/application.d.ts
+declare class TEggPluginApplication extends Application {
+  get eggPrototypeCreatorFactory(): typeof EggPrototypeCreatorFactory;
+  get eggPrototypeFactory(): EggPrototypeFactory;
+  get loadUnitLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_metadata0.LoadUnitLifecycleContext, _eggjs_tegg_metadata0.LoadUnit>;
+  get loadUnitFactory(): typeof LoadUnitFactory;
+  get eggObjectFactory(): typeof EggObjectFactory;
+  get loadUnitInstanceFactory(): typeof LoadUnitInstanceFactory;
+  get loadUnitInstanceLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_runtime0.LoadUnitInstanceLifecycleContext, _eggjs_tegg_runtime0.LoadUnitInstance>;
+  get eggContainerFactory(): typeof EggContainerFactory;
+  get loaderFactory(): typeof LoaderFactory;
+  get eggPrototypeLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_metadata0.EggPrototypeLifecycleContext, _eggjs_tegg_metadata0.EggPrototype>;
+  get eggContextLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_runtime0.EggContextLifecycleContext, EggContext>;
+  get eggObjectLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_runtime0.EggObjectLifeCycleContext, _eggjs_tegg_runtime0.EggObject>;
+  get abstractEggContext(): typeof AbstractEggContext;
+  get identicalUtil(): typeof IdenticalUtil;
+  get runtimeConfig(): RuntimeConfig;
+  getEggObject<T>(clazz: EggProtoImplClass<T>, name?: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+  getEggObjectFromName<T extends object>(name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+}
+declare module 'egg' {
+  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;
+  }
+}
+//#endregion
+export { TEggPluginApplication };

package/dist/application-DFI1junS.js

@@ -0,0 +1,70 @@
+import { EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from "@eggjs/tegg-metadata";
+import { IdenticalUtil } from "@eggjs/tegg";
+import { AbstractEggContext, EggContainerFactory, EggContextLifecycleUtil, EggObjectFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
+import { Application } from "egg";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+
+//#region src/app/extend/application.ts
+var TEggPluginApplication = class extends Application {
+	get eggPrototypeCreatorFactory() {
+		return EggPrototypeCreatorFactory;
+	}
+	get eggPrototypeFactory() {
+		return EggPrototypeFactory.instance;
+	}
+	get loadUnitLifecycleUtil() {
+		return LoadUnitLifecycleUtil;
+	}
+	get loadUnitFactory() {
+		return LoadUnitFactory;
+	}
+	get eggObjectFactory() {
+		return EggObjectFactory;
+	}
+	get loadUnitInstanceFactory() {
+		return LoadUnitInstanceFactory;
+	}
+	get loadUnitInstanceLifecycleUtil() {
+		return LoadUnitInstanceLifecycleUtil;
+	}
+	get eggContainerFactory() {
+		return EggContainerFactory;
+	}
+	get loaderFactory() {
+		return LoaderFactory;
+	}
+	get eggPrototypeLifecycleUtil() {
+		return EggPrototypeLifecycleUtil;
+	}
+	get eggContextLifecycleUtil() {
+		return EggContextLifecycleUtil;
+	}
+	get eggObjectLifecycleUtil() {
+		return EggObjectLifecycleUtil;
+	}
+	get abstractEggContext() {
+		return AbstractEggContext;
+	}
+	get identicalUtil() {
+		return IdenticalUtil;
+	}
+	get runtimeConfig() {
+		const config = this.config;
+		return {
+			baseDir: config.baseDir,
+			env: config.env,
+			name: config.name
+		};
+	}
+	async getEggObject(clazz, name, qualifiers) {
+		if (qualifiers) qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];
+		return (await EggContainerFactory.getOrCreateEggObjectFromClazz(clazz, name, qualifiers)).obj;
+	}
+	async getEggObjectFromName(name, qualifiers) {
+		if (qualifiers) qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];
+		return (await EggContainerFactory.getOrCreateEggObjectFromName(name, qualifiers)).obj;
+	}
+};
+
+//#endregion
+export { TEggPluginApplication };

package/dist/application.unittest-Cmia71Fx.js

@@ -0,0 +1,43 @@
+import { EggContextImpl } from "./EggContextImpl-DkCLPTzT.js";
+import "@eggjs/tegg-runtime";
+import { Application } from "egg";
+
+//#region src/app/extend/application.unittest.ts
+const TEGG_LIFECYCLE_CACHE = /* @__PURE__ */ new Map();
+let hasMockModuleContext = false;
+var TEggPluginApplicationUnittest = class extends Application {
+	async mockModuleContext(data) {
+		this.deprecate("app.mockModuleContext is deprecated, use mockModuleContextScope.");
+		if (hasMockModuleContext) throw new Error("should not call mockModuleContext twice.");
+		const ctx = this.mockContext(data);
+		const teggCtx = new EggContextImpl(ctx);
+		const lifecycle = {};
+		TEGG_LIFECYCLE_CACHE.set(teggCtx, lifecycle);
+		if (teggCtx.init) await teggCtx.init(lifecycle);
+		hasMockModuleContext = true;
+		return ctx;
+	}
+	async destroyModuleContext(ctx) {
+		hasMockModuleContext = false;
+		const teggCtx = ctx.teggContext;
+		if (!teggCtx) return;
+		const lifecycle = TEGG_LIFECYCLE_CACHE.get(teggCtx);
+		if (teggCtx.destroy && lifecycle) await teggCtx.destroy(lifecycle);
+	}
+	async mockModuleContextScope(fn, data) {
+		if (hasMockModuleContext) throw new Error("mockModuleContextScope can not use with mockModuleContext, should use mockModuleContextScope only.");
+		return this.mockContextScope(async (ctx) => {
+			const teggCtx = new EggContextImpl(ctx);
+			const lifecycle = {};
+			if (teggCtx.init) await teggCtx.init(lifecycle);
+			try {
+				return await fn(ctx);
+			} finally {
+				await teggCtx.destroy(lifecycle);
+			}
+		}, data);
+	}
+};
+
+//#endregion
+export { TEggPluginApplicationUnittest };

package/dist/application.unittest-CpoCu6-E.d.ts

@@ -0,0 +1,26 @@
+import { Application, Context } from "egg";
+
+//#region src/app/extend/application.unittest.d.ts
+declare class TEggPluginApplicationUnittest extends Application {
+  mockModuleContext(data?: any): Promise<Context>;
+  destroyModuleContext(ctx: Context): Promise<void>;
+  mockModuleContextScope<R = any>(fn: (ctx: Context) => Promise<R>, data?: any): Promise<R>;
+}
+declare module 'egg' {
+  interface Application {
+    /**
+     * 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>;
+  }
+}
+//#endregion
+export { TEggPluginApplicationUnittest };

package/dist/context-BWYE1dif.js

@@ -0,0 +1,30 @@
+import { ctxLifecycleMiddleware } from "./ctx_lifecycle_middleware-CIeSrbVY.js";
+import "@eggjs/tegg-metadata";
+import { PrototypeUtil } from "@eggjs/tegg";
+import { TEGG_CONTEXT } from "@eggjs/egg-module-common";
+import { Context } from "egg";
+
+//#region src/app/extend/context.ts
+var TEggPluginContext = class extends Context {
+	[TEGG_CONTEXT];
+	async beginModuleScope(func) {
+		await ctxLifecycleMiddleware(this, func);
+	}
+	get teggContext() {
+		if (!this[TEGG_CONTEXT]) throw new Error("tegg context have not ready, should call after teggCtxLifecycleMiddleware");
+		return this[TEGG_CONTEXT];
+	}
+	async getEggObject(clazz, name) {
+		const protoObj = PrototypeUtil.getClazzProto(clazz);
+		if (!protoObj) throw new Error(`can not get proto for clazz ${clazz.name}`);
+		const proto = protoObj;
+		return (await this.app.eggContainerFactory.getOrCreateEggObject(proto, name ?? proto.name)).obj;
+	}
+	async getEggObjectFromName(name, qualifiers) {
+		if (qualifiers) qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];
+		return (await this.app.eggContainerFactory.getOrCreateEggObjectFromName(name, qualifiers)).obj;
+	}
+};
+
+//#endregion
+export { TEggPluginContext };

package/dist/context-BoIt2G5h.d.ts

@@ -0,0 +1,24 @@
+import { EggProtoImplClass, QualifierInfo } from "@eggjs/tegg";
+import { EggContext } from "@eggjs/tegg-runtime";
+import { TEGG_CONTEXT } from "@eggjs/egg-module-common";
+import { Context } from "egg";
+
+//#region src/app/extend/context.d.ts
+declare class TEggPluginContext extends Context {
+  [TEGG_CONTEXT]: EggContext | undefined;
+  beginModuleScope(func: () => Promise<void>): Promise<void>;
+  get teggContext(): EggContext;
+  getEggObject<T>(clazz: EggProtoImplClass<T>, name?: string): Promise<T>;
+  getEggObjectFromName<T>(name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+}
+declare module 'egg' {
+  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;
+  }
+}
+//#endregion
+export { TEggPluginContext };

package/dist/ctx_lifecycle_middleware-CIeSrbVY.js

@@ -0,0 +1,27 @@
+import { EggContextImpl } from "./EggContextImpl-DkCLPTzT.js";
+import "@eggjs/tegg-runtime";
+import { ROOT_PROTO, TEGG_CONTEXT } from "@eggjs/egg-module-common";
+
+//#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);
+	try {
+		await next();
+	} finally {
+		if (teggCtx.destroy) teggCtx.destroy(lifecycleCtx).catch((e) => {
+			e.message = `[tegg/ctxLifecycleMiddleware] destroy tegg ctx failed: ${e.message}`;
+			ctx.logger.error(e);
+		});
+	}
+}
+
+//#endregion
+export { ctxLifecycleMiddleware };

package/dist/ctx_lifecycle_middleware-DV7uN5PG.d.ts

@@ -0,0 +1,6 @@
+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/index.d.ts

@@ -1 +1,6 @@
-export { };
+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";

package/dist/index.js

@@ -1,5 +1,15 @@
-import "./app/extend/context.js";
-import "./app/extend/application.js";
-import "./types.js";
+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";
 
 export {  };

package/dist/lib/AppLoadUnit.d.ts

@@ -1,23 +1,2 @@
-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
+import { AppLoadUnit } from "../AppLoadUnit-BOWdS4O9.js";
 export { AppLoadUnit };

package/dist/lib/AppLoadUnit.js

@@ -1,78 +1,3 @@
-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";
+import { AppLoadUnit } from "../AppLoadUnit-uyHgElRL.js";
 
-//#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/lib/AppLoadUnitInstance.d.ts

@@ -1,24 +1,2 @@
-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
+import { AppLoadUnitInstance } from "../AppLoadUnitInstance-DQ-DxlmR.js";
 export { AppLoadUnitInstance };

package/dist/lib/AppLoadUnitInstance.js

@@ -1,69 +1,3 @@
-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";
+import { AppLoadUnitInstance } from "../AppLoadUnitInstance-4Z_vSQV3.js";
 
-//#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/lib/CompatibleUtil.js

@@ -1,96 +1,3 @@
-import { EggPrototypeFactory } from "@eggjs/tegg-metadata";
-import { InitTypeQualifierAttribute, ObjectInitType } from "@eggjs/tegg";
-import { ProxyUtil } from "@eggjs/tegg-common-util";
-import { EggContainerFactory } from "@eggjs/tegg-runtime";
-import { Application, Context } from "egg";
+import { CompatibleUtil } from "../CompatibleUtil-CNhydb0E.js";
 
-//#region src/lib/CompatibleUtil.ts
-var CompatibleUtil = class CompatibleUtil {
-	static singletonProtoCache = /* @__PURE__ */ new Map();
-	static requestProtoCache = /* @__PURE__ */ new Map();
-	static getSingletonProto(name) {
-		if (!this.singletonProtoCache.has(name)) {
-			const proto = EggPrototypeFactory.instance.getPrototype(name, void 0, [{
-				attribute: InitTypeQualifierAttribute,
-				value: ObjectInitType.SINGLETON
-			}]);
-			this.singletonProtoCache.set(name, proto);
-		}
-		return this.singletonProtoCache.get(name);
-	}
-	static getRequestProto(name) {
-		if (!this.requestProtoCache.has(name)) {
-			const proto = EggPrototypeFactory.instance.getPrototype(name, void 0, [{
-				attribute: InitTypeQualifierAttribute,
-				value: ObjectInitType.CONTEXT
-			}]);
-			this.requestProtoCache.set(name, proto);
-		}
-		return this.requestProtoCache.get(name);
-	}
-	static singletonModuleProxyFactory(app, loadUnitInstance) {
-		let deprecated = false;
-		return function(_, p) {
-			const proto = CompatibleUtil.getSingletonProto(p);
-			const eggObj = EggContainerFactory.getEggObject(proto);
-			if (!deprecated) {
-				deprecated = true;
-				app.deprecate(`[egg/module] Please use await app.getEggObject(clazzName) instead of app.${loadUnitInstance.name}.${String(p)}`);
-			}
-			return eggObj.obj;
-		};
-	}
-	static appCompatible(app, loadUnitInstance) {
-		const moduleLoadUnitProxy = ProxyUtil.safeProxy(loadUnitInstance, CompatibleUtil.singletonModuleProxyFactory(app, loadUnitInstance));
-		Reflect.defineProperty(app.module, loadUnitInstance.name, {
-			configurable: true,
-			value: moduleLoadUnitProxy
-		});
-	}
-	static contextModuleProxyFactory(holder, ctx, loadUnitInstance) {
-		const cacheKey = `_${loadUnitInstance.name}Proxy`;
-		if (!holder[cacheKey]) {
-			let deprecated = false;
-			const getter = function(_, p) {
-				const proto = CompatibleUtil.getRequestProto(p);
-				const eggObj = EggContainerFactory.getEggObject(proto, p);
-				if (!deprecated) {
-					deprecated = true;
-					ctx.app.deprecate(`[egg/module] Please use await ctx.getEggObject(clazzName) instead of ctx.${loadUnitInstance.name}.${String(p)}`);
-				}
-				return eggObj.obj;
-			};
-			holder[cacheKey] = ProxyUtil.safeProxy(loadUnitInstance, getter);
-		}
-		return holder[cacheKey];
-	}
-	static contextModuleCompatible(ctx, loadUnitInstances) {
-		const loadUnitInstanceMap = loadUnitInstances.reduce((p, c) => {
-			p[c.name] = c;
-			return p;
-		}, {});
-		Reflect.defineProperty(ctx, "module", {
-			configurable: true,
-			enumerable: true,
-			get() {
-				const ctx$1 = this;
-				if (!this._moduleProxy) {
-					const ctxModule = Object.create(loadUnitInstanceMap);
-					this._moduleProxy = ProxyUtil.safeProxy(ctxModule, (_, p) => {
-						const loadUnitInstance = Reflect.get(ctxModule, p);
-						if (!loadUnitInstance) return;
-						return CompatibleUtil.contextModuleProxyFactory(ctxModule, ctx$1, loadUnitInstance);
-					});
-				}
-				return this._moduleProxy;
-			}
-		});
-	}
-	static clean() {
-		this.singletonProtoCache.clear();
-		this.requestProtoCache.clear();
-	}
-};
-
-//#endregion
 export { CompatibleUtil };

package/dist/lib/ConfigSourceLoadUnitHook.js

@@ -1,22 +1,3 @@
-import "@eggjs/tegg-metadata";
-import { ConfigSourceQualifier, ConfigSourceQualifierAttribute, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
+import { ConfigSourceLoadUnitHook } from "../ConfigSourceLoadUnitHook-BV-R31vA.js";
 
-//#region src/lib/ConfigSourceLoadUnitHook.ts
-/**
-* Copy from standalone/src/ConfigSourceLoadUnitHook
-* Hook for inject moduleConfig.
-* Add default qualifier value is current module name.
-*/
-var ConfigSourceLoadUnitHook = class {
-	async preCreate(ctx, loadUnit) {
-		const classList = await ctx.loader.load();
-		for (const clazz of classList) {
-			const moduleConfigObject = PrototypeUtil.getInjectObjects(clazz).find((t) => t.objName === "moduleConfig");
-			const configSourceQualifier = QualifierUtil.getProperQualifier(clazz, "moduleConfig", ConfigSourceQualifierAttribute);
-			if (moduleConfigObject && !configSourceQualifier) ConfigSourceQualifier(loadUnit.name)(clazz.prototype, moduleConfigObject.refName);
-		}
-	}
-};
-
-//#endregion
 export { ConfigSourceLoadUnitHook };