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

package/dist/lib/EggAppLoader.js

@@ -1,106 +1,5 @@
-import { COMPATIBLE_PROTO_IMPLE_TYPE } from "./EggCompatibleProtoImpl.js";
-import { ModuleConfigLoader } from "./ModuleConfigLoader.js";
-import { TeggError } from "@eggjs/tegg-metadata";
-import { AccessLevel, EggQualifierAttribute, EggType, InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, ObjectInitType, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
-import { ObjectUtils } from "@eggjs/tegg-common-util";
-import { Application } from "egg";
-import { BackgroundTaskHelper as BackgroundTaskHelper$1 } from "@eggjs/tegg-background-task";
-import { EggObjectFactory } from "@eggjs/tegg-dynamic-inject-runtime";
+import "../EggCompatibleProtoImpl-CPxLvSu4.js";
+import "../ModuleConfigLoader-CvZLf99E.js";
+import { APP_CLAZZ_BLACK_LIST, CONTEXT_CLAZZ_BLACK_LIST, DEFAULT_APP_CLAZZ, DEFAULT_CONTEXT_CLAZZ, EggAppLoader } from "../EggAppLoader-DFYg65ry.js";
 
-//#region src/lib/EggAppLoader.ts
-const APP_CLAZZ_BLACK_LIST = ["eggObjectFactory", "moduleConfigs"];
-const CONTEXT_CLAZZ_BLACK_LIST = ["logger"];
-const DEFAULT_APP_CLAZZ = [];
-const DEFAULT_CONTEXT_CLAZZ = ["user"];
-var EggAppLoader = class {
-	app;
-	moduleConfigLoader;
-	constructor(app) {
-		this.app = app;
-		this.moduleConfigLoader = new ModuleConfigLoader(this.app);
-	}
-	buildClazz(name, eggType) {
-		const app = this.app;
-		let func;
-		if (eggType === EggType.APP) func = function() {
-			return app[name];
-		};
-		else func = function() {
-			const ctx = app.currentContext;
-			if (!ctx) throw TeggError.create(`Can not read property \`${name}\` because egg ctx has been destroyed`, "read_after_ctx_destroyed");
-			return ctx[name];
-		};
-		Object.defineProperty(func, "name", {
-			value: name,
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
-		PrototypeUtil.setIsEggPrototype(func);
-		PrototypeUtil.setFilePath(func, "mock_file_path");
-		PrototypeUtil.setProperty(func, {
-			name,
-			initType: ObjectInitType.SINGLETON,
-			accessLevel: AccessLevel.PUBLIC,
-			protoImplType: COMPATIBLE_PROTO_IMPLE_TYPE
-		});
-		QualifierUtil.addProtoQualifier(func, LoadUnitNameQualifierAttribute, "app");
-		QualifierUtil.addProtoQualifier(func, InitTypeQualifierAttribute, ObjectInitType.SINGLETON);
-		QualifierUtil.addProtoQualifier(func, EggQualifierAttribute, eggType);
-		return func;
-	}
-	buildAppLoggerClazz(name) {
-		const app = this.app;
-		const func = function() {
-			return app.getLogger(name);
-		};
-		Object.defineProperty(func, "name", {
-			value: name,
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
-		PrototypeUtil.setIsEggPrototype(func);
-		PrototypeUtil.setFilePath(func, "mock_file_path");
-		PrototypeUtil.setProperty(func, {
-			name,
-			initType: ObjectInitType.SINGLETON,
-			accessLevel: AccessLevel.PUBLIC,
-			protoImplType: COMPATIBLE_PROTO_IMPLE_TYPE
-		});
-		QualifierUtil.addProtoQualifier(func, LoadUnitNameQualifierAttribute, "app");
-		QualifierUtil.addProtoQualifier(func, InitTypeQualifierAttribute, ObjectInitType.SINGLETON);
-		QualifierUtil.addProtoQualifier(func, EggQualifierAttribute, EggType.APP);
-		return func;
-	}
-	getLoggerNames(ctxClazzNames, singletonClazzNames) {
-		return Array.from(this.app.loggers.keys()).filter((t) => !ctxClazzNames.includes(t) && !singletonClazzNames.includes(t));
-	}
-	async load() {
-		const app = this.app;
-		const appProperties = ObjectUtils.getProperties(app);
-		const contextProperties = ObjectUtils.getProperties(app.context);
-		const allSingletonClazzNameSet = new Set([...appProperties, ...DEFAULT_APP_CLAZZ]);
-		APP_CLAZZ_BLACK_LIST.forEach((t) => allSingletonClazzNameSet.delete(t));
-		const allSingletonClazzNames = Array.from(allSingletonClazzNameSet);
-		const allContextClazzNamesSet = new Set([...contextProperties, ...DEFAULT_CONTEXT_CLAZZ]);
-		CONTEXT_CLAZZ_BLACK_LIST.forEach((t) => allContextClazzNamesSet.delete(t));
-		const allContextClazzNames = Array.from(allContextClazzNamesSet);
-		const loggerNames = this.getLoggerNames(allContextClazzNames, allSingletonClazzNames);
-		const allSingletonClazzs = allSingletonClazzNames.map((name) => this.buildClazz(name, EggType.APP));
-		const allContextClazzs = allContextClazzNames.map((name) => this.buildClazz(name, EggType.CONTEXT));
-		const appLoggerClazzs = loggerNames.map((name) => this.buildAppLoggerClazz(name));
-		const moduleConfigList = this.moduleConfigLoader.loadModuleConfigList();
-		return [
-			...allSingletonClazzs,
-			...allContextClazzs,
-			...appLoggerClazzs,
-			...moduleConfigList,
-			BackgroundTaskHelper$1,
-			EggObjectFactory
-		];
-	}
-};
-
-//#endregion
 export { APP_CLAZZ_BLACK_LIST, CONTEXT_CLAZZ_BLACK_LIST, DEFAULT_APP_CLAZZ, DEFAULT_CONTEXT_CLAZZ, EggAppLoader };

package/dist/lib/EggCompatibleObject.d.ts

@@ -1,21 +1,3 @@
-import { EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl.js";
-import { EggPrototype } from "@eggjs/tegg-metadata";
-import { EggObjectName } from "@eggjs/tegg";
-import { EggObject } from "@eggjs/tegg-runtime";
-
-//#region src/lib/EggCompatibleObject.d.ts
-declare const OBJ: unique symbol;
-declare class EggCompatibleObject implements EggObject {
-  readonly isReady: boolean;
-  private [OBJ];
-  readonly proto: EggCompatibleProtoImpl;
-  readonly name: EggObjectName;
-  readonly id: string;
-  readonly isContext: boolean;
-  constructor(name: EggObjectName, proto: EggCompatibleProtoImpl);
-  get obj(): object;
-  injectProperty(): void;
-  static createObject(name: EggObjectName, proto: EggPrototype): Promise<EggCompatibleObject>;
-}
-//#endregion
+import "../EggCompatibleProtoImpl-DpacWKFB.js";
+import { EggCompatibleObject } from "../EggCompatibleObject-lzUCfsIY.js";
 export { EggCompatibleObject };

package/dist/lib/EggCompatibleObject.js

@@ -1,37 +1,4 @@
-import { EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl.js";
-import "@eggjs/tegg-metadata";
-import { EggQualifierAttribute, EggType, IdenticalUtil } from "@eggjs/tegg";
-import { EggObjectFactory } from "@eggjs/tegg-runtime";
+import "../EggCompatibleProtoImpl-CPxLvSu4.js";
+import { EggCompatibleObject } from "../EggCompatibleObject-XfIZyirS.js";
 
-//#region src/lib/EggCompatibleObject.ts
-const OBJ = Symbol("EggCompatibleObject#obj");
-var EggCompatibleObject = class EggCompatibleObject {
-	isReady = true;
-	[OBJ];
-	proto;
-	name;
-	id;
-	isContext;
-	constructor(name, proto) {
-		this.proto = proto;
-		this.name = name;
-		this.id = IdenticalUtil.createObjectId(this.proto.id);
-		this.isContext = this.proto.verifyQualifier({
-			value: EggType.CONTEXT,
-			attribute: EggQualifierAttribute
-		});
-	}
-	get obj() {
-		if (this.isContext) return this.proto.constructEggObject();
-		if (!this[OBJ]) this[OBJ] = this.proto.constructEggObject();
-		return this[OBJ];
-	}
-	injectProperty() {}
-	static async createObject(name, proto) {
-		return new EggCompatibleObject(name, proto);
-	}
-};
-EggObjectFactory.registerEggObjectCreateMethod(EggCompatibleProtoImpl, EggCompatibleObject.createObject);
-
-//#endregion
 export { EggCompatibleObject };

package/dist/lib/EggCompatibleProtoImpl.d.ts

@@ -1,25 +1,2 @@
-import { EggPrototype, EggPrototypeLifecycleContext, InjectObjectProto } from "@eggjs/tegg-metadata";
-import { AccessLevel, EggProtoImplClass, EggPrototypeName, Id, MetaDataKey, ObjectInitTypeLike, QualifierInfo, QualifierValue } from "@eggjs/tegg";
-
-//#region src/lib/EggCompatibleProtoImpl.d.ts
-declare const COMPATIBLE_PROTO_IMPLE_TYPE = "EGG_COMPATIBLE";
-declare class EggCompatibleProtoImpl implements EggPrototype {
-  [key: symbol]: PropertyDescriptor;
-  private readonly clazz;
-  private readonly qualifiers;
-  readonly id: string;
-  readonly name: EggPrototypeName;
-  readonly initType: ObjectInitTypeLike;
-  readonly accessLevel: AccessLevel;
-  readonly injectObjects: InjectObjectProto[];
-  readonly loadUnitId: Id;
-  constructor(id: string, name: EggPrototypeName, clazz: EggProtoImplClass, initType: ObjectInitTypeLike, loadUnitId: Id, qualifiers: QualifierInfo[]);
-  verifyQualifiers(qualifiers: QualifierInfo[]): boolean;
-  verifyQualifier(qualifier: QualifierInfo): boolean;
-  getQualifier(attribute: string): QualifierValue | undefined;
-  constructEggObject(): object;
-  getMetaData<T>(metadataKey: MetaDataKey): T | undefined;
-  static create(ctx: EggPrototypeLifecycleContext): EggPrototype;
-}
-//#endregion
+import { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl } from "../EggCompatibleProtoImpl-DpacWKFB.js";
 export { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl };

package/dist/lib/EggCompatibleProtoImpl.js

@@ -1,50 +1,3 @@
-import "@eggjs/tegg-metadata";
-import { AccessLevel, IdenticalUtil, MetadataUtil, QualifierUtil } from "@eggjs/tegg";
+import { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl } from "../EggCompatibleProtoImpl-CPxLvSu4.js";
 
-//#region src/lib/EggCompatibleProtoImpl.ts
-const COMPATIBLE_PROTO_IMPLE_TYPE = "EGG_COMPATIBLE";
-var EggCompatibleProtoImpl = class EggCompatibleProtoImpl {
-	clazz;
-	qualifiers;
-	id;
-	name;
-	initType;
-	accessLevel;
-	injectObjects;
-	loadUnitId;
-	constructor(id, name, clazz, initType, loadUnitId, qualifiers) {
-		this.id = id;
-		this.clazz = clazz;
-		this.name = name;
-		this.initType = initType;
-		this.accessLevel = AccessLevel.PUBLIC;
-		this.injectObjects = [];
-		this.loadUnitId = loadUnitId;
-		this.qualifiers = qualifiers;
-	}
-	verifyQualifiers(qualifiers) {
-		for (const qualifier of qualifiers) if (!this.verifyQualifier(qualifier)) return false;
-		return true;
-	}
-	verifyQualifier(qualifier) {
-		return this.qualifiers.find((t) => t.attribute === qualifier.attribute)?.value === qualifier.value;
-	}
-	getQualifier(attribute) {
-		return this.qualifiers.find((t) => t.attribute === attribute)?.value;
-	}
-	constructEggObject() {
-		return Reflect.apply(this.clazz, null, []);
-	}
-	getMetaData(metadataKey) {
-		return MetadataUtil.getMetaData(metadataKey, this.clazz);
-	}
-	static create(ctx) {
-		const { clazz, loadUnit } = ctx;
-		const name = ctx.prototypeInfo.name;
-		const id = IdenticalUtil.createProtoId(loadUnit.id, name);
-		return new EggCompatibleProtoImpl(id, name, clazz, ctx.prototypeInfo.initType, loadUnit.id, QualifierUtil.mergeQualifiers(QualifierUtil.getProtoQualifiers(clazz), ctx.prototypeInfo.qualifiers ?? []));
-	}
-};
-
-//#endregion
 export { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl };

package/dist/lib/EggContextCompatibleHook.d.ts

@@ -1,4 +1,4 @@
-import { ModuleHandler } from "./ModuleHandler.js";
+import { ModuleHandler } from "../ModuleHandler-Dyx7JGj-.js";
 import { LifecycleHook } from "@eggjs/tegg";
 import { EggContext, EggContextLifecycleContext } from "@eggjs/tegg-runtime";
 

package/dist/lib/EggContextCompatibleHook.js

@@ -1,32 +1,9 @@
-import "./ModuleHandler.js";
-import "@eggjs/tegg-metadata";
-import { BackgroundTaskHelper, ObjectInitType, PrototypeUtil } from "@eggjs/tegg";
-import { EggContainerFactory } from "@eggjs/tegg-runtime";
-import { ROOT_PROTO } from "@eggjs/egg-module-common";
+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 { EggContextCompatibleHook } from "../EggContextCompatibleHook-eFfN2xm6.js";
 
-//#region src/lib/EggContextCompatibleHook.ts
-var EggContextCompatibleHook = class {
-	moduleHandler;
-	requestProtoList = [];
-	constructor(moduleHandler) {
-		this.moduleHandler = moduleHandler;
-		for (const loadUnitInstance of this.moduleHandler.loadUnitInstances) {
-			const iterator = loadUnitInstance.loadUnit.iterateEggPrototype();
-			for (const proto of iterator) if (proto.initType === ObjectInitType.CONTEXT) this.requestProtoList.push(proto);
-		}
-	}
-	async preCreate(_, ctx) {
-		if (!ctx.get(ROOT_PROTO)) for (const proto of this.requestProtoList) ctx.addProtoToCreate(proto.name, proto);
-		else {
-			const protoObj = PrototypeUtil.getClazzProto(BackgroundTaskHelper);
-			await EggContainerFactory.getOrCreateEggObject(protoObj);
-		}
-	}
-	async postCreate(_, ctx) {
-		const rootProto = ctx.get(ROOT_PROTO);
-		if (rootProto) await EggContainerFactory.getOrCreateEggObject(rootProto);
-	}
-};
-
-//#endregion
 export { EggContextCompatibleHook };

package/dist/lib/EggContextHandler.d.ts

@@ -1,13 +1,2 @@
-import { EggContext } from "@eggjs/tegg-runtime";
-import { Application } from "egg";
-
-//#region src/lib/EggContextHandler.d.ts
-declare class EggContextHandler {
-  private readonly app;
-  constructor(app: Application);
-  getContextCallback(): EggContext | undefined;
-  run<R>(eggContext: EggContext, fn: () => Promise<R>): Promise<R>;
-  register(): void;
-}
-//#endregion
+import { EggContextHandler } from "../EggContextHandler-vGi67He5.js";
 export { EggContextHandler };

package/dist/lib/EggContextHandler.js

@@ -1,29 +1,3 @@
-import { ContextHandler } from "@eggjs/tegg-runtime";
-import { EGG_CONTEXT } from "@eggjs/egg-module-common";
-import "egg";
+import { EggContextHandler } from "../EggContextHandler-D8gfTbZs.js";
 
-//#region src/lib/EggContextHandler.ts
-var EggContextHandler = class {
-	app;
-	constructor(app) {
-		this.app = app;
-	}
-	getContextCallback() {
-		return this.app.currentContext?.teggContext;
-	}
-	async run(eggContext, fn) {
-		const ctx = eggContext.get(EGG_CONTEXT);
-		return await this.app.ctxStorage.run(ctx, fn);
-	}
-	register() {
-		ContextHandler.getContextCallback = () => {
-			return this.getContextCallback();
-		};
-		ContextHandler.runInContextCallback = async (context, fn) => {
-			return await this.run(context, fn);
-		};
-	}
-};
-
-//#endregion
 export { EggContextHandler };

package/dist/lib/EggContextImpl.js

@@ -1,18 +1,3 @@
-import { IdenticalUtil } from "@eggjs/tegg";
-import { AbstractEggContext } from "@eggjs/tegg-runtime";
-import { EGG_CONTEXT, TEGG_CONTEXT } from "@eggjs/egg-module-common";
+import { EggContextImpl } from "../EggContextImpl-DkCLPTzT.js";
 
-//#region src/lib/EggContextImpl.ts
-var EggContextImpl = class extends AbstractEggContext {
-	id;
-	constructor(ctx) {
-		super();
-		this.set(EGG_CONTEXT, ctx);
-		ctx[TEGG_CONTEXT] = this;
-		const tracer = ctx.tracer;
-		this.id = IdenticalUtil.createContextId(tracer?.traceId);
-	}
-};
-
-//#endregion
 export { EggContextImpl };

package/dist/lib/EggModuleLoader.js

@@ -1,50 +1,6 @@
-import { EggAppLoader } from "./EggAppLoader.js";
-import { EggLoadUnitType, GlobalGraph, LoadUnitFactory, ModuleDescriptorDumper } from "@eggjs/tegg-metadata";
-import { Application } from "egg";
-import { LoaderFactory } from "@eggjs/tegg-loader";
+import "../EggCompatibleProtoImpl-CPxLvSu4.js";
+import "../ModuleConfigLoader-CvZLf99E.js";
+import "../EggAppLoader-DFYg65ry.js";
+import { EggModuleLoader } from "../EggModuleLoader-CCfQMmp5.js";
 
-//#region src/lib/EggModuleLoader.ts
-var EggModuleLoader = class {
-	app;
-	globalGraph;
-	constructor(app) {
-		this.app = app;
-	}
-	async loadApp() {
-		const loader = new EggAppLoader(this.app);
-		const loadUnit = await LoadUnitFactory.createLoadUnit(this.app.baseDir, EggLoadUnitType.APP, loader);
-		this.app.moduleHandler.loadUnits.push(loadUnit);
-	}
-	async buildAppGraph() {
-		for (const plugin of Object.values(this.app.plugins)) {
-			if (!plugin.enable) continue;
-			const modulePlugin = this.app.moduleReferences.find((t) => t.path === plugin.path);
-			if (modulePlugin) modulePlugin.optional = false;
-		}
-		const moduleDescriptors = await LoaderFactory.loadApp(this.app.moduleReferences);
-		for (const moduleDescriptor of moduleDescriptors) ModuleDescriptorDumper.dump(moduleDescriptor, { dumpDir: this.app.baseDir }).catch((e) => {
-			e.message = "dump module descriptor failed: " + e.message;
-			this.app.logger.warn(e);
-		});
-		return await GlobalGraph.create(moduleDescriptors);
-	}
-	async loadModule() {
-		this.globalGraph.build();
-		this.globalGraph.sort();
-		const moduleConfigList = this.globalGraph.moduleConfigList;
-		for (const moduleConfig of moduleConfigList) {
-			const modulePath = moduleConfig.path;
-			const loader = LoaderFactory.createLoader(modulePath, EggLoadUnitType.MODULE);
-			const loadUnit = await LoadUnitFactory.createLoadUnit(modulePath, EggLoadUnitType.MODULE, loader);
-			this.app.moduleHandler.loadUnits.push(loadUnit);
-		}
-	}
-	async load() {
-		GlobalGraph.instance = this.globalGraph = await this.buildAppGraph();
-		await this.loadApp();
-		await this.loadModule();
-	}
-};
-
-//#endregion
 export { EggModuleLoader };

package/dist/lib/EggQualifierProtoHook.js

@@ -1,48 +1,6 @@
-import { APP_CLAZZ_BLACK_LIST, CONTEXT_CLAZZ_BLACK_LIST, DEFAULT_APP_CLAZZ, DEFAULT_CONTEXT_CLAZZ } from "./EggAppLoader.js";
-import { debuglog } from "node:util";
-import "@eggjs/tegg-metadata";
-import { EggQualifierAttribute, EggType, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
-import { ObjectUtils } from "@eggjs/tegg-common-util";
-import { Application } from "egg";
+import "../EggCompatibleProtoImpl-CPxLvSu4.js";
+import "../ModuleConfigLoader-CvZLf99E.js";
+import "../EggAppLoader-DFYg65ry.js";
+import { EggQualifierProtoHook } from "../EggQualifierProtoHook-D5jNm-1y.js";
 
-//#region src/lib/EggQualifierProtoHook.ts
-const debug = debuglog("tegg/plugin/tegg/lib/EggQualifierProtoHook");
-var EggQualifierProtoHook = class {
-	app;
-	constructor(app) {
-		this.app = app;
-	}
-	async preCreate(ctx) {
-		const clazzList = await ctx.loader.load();
-		const appProperties = ObjectUtils.getProperties(this.app);
-		const ctxProperties = ObjectUtils.getProperties(this.app.context);
-		if (debug.enabled) debug("preCreate, get clazzList:%o, appProperties:%o, ctxProperties:%o, from unitPath:%o", clazzList.map((t) => t.name), appProperties.length, ctxProperties.length, ctx.unitPath);
-		for (const clazz of clazzList) {
-			const inbjectObjects = PrototypeUtil.getInjectObjects(clazz) || [];
-			if (debug.enabled && inbjectObjects.length > 0) debug("preCreate, get injectObjects:%o, from clazz:%o, from unitPath:%o", inbjectObjects.map((t) => t.refName), clazz.name, ctx.unitPath);
-			for (const injectObject of inbjectObjects) {
-				if (QualifierUtil.getProperQualifiers(clazz, injectObject.refName).find((t) => t.attribute === EggQualifierAttribute)) continue;
-				if (this.isCtxObject(injectObject.objName, ctxProperties)) QualifierUtil.addProperQualifier(clazz, injectObject.refName, EggQualifierAttribute, EggType.CONTEXT);
-				else if (this.isAppObject(injectObject.objName, appProperties)) {
-					QualifierUtil.addProperQualifier(clazz, injectObject.refName, EggQualifierAttribute, EggType.APP);
-					debug("preCreate, add proper qualifier:%o to clazz:%o, from unitPath:%o", injectObject.refName, clazz.name, ctx.unitPath);
-				}
-			}
-		}
-	}
-	isAppObject(name, appProperties) {
-		name = String(name);
-		if (APP_CLAZZ_BLACK_LIST.includes(name)) return false;
-		if (DEFAULT_APP_CLAZZ.includes(name)) return true;
-		return appProperties.includes(name);
-	}
-	isCtxObject(name, ctxProperties) {
-		name = String(name);
-		if (CONTEXT_CLAZZ_BLACK_LIST.includes(name)) return false;
-		if (DEFAULT_CONTEXT_CLAZZ.includes(name)) return true;
-		return ctxProperties.includes(name);
-	}
-};
-
-//#endregion
 export { EggQualifierProtoHook };

package/dist/lib/ModuleConfigLoader.js

@@ -1,84 +1,4 @@
-import { COMPATIBLE_PROTO_IMPLE_TYPE } from "./EggCompatibleProtoImpl.js";
-import { AccessLevel, ConfigSourceQualifierAttribute, EggQualifierAttribute, EggType, InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, ModuleConfigs, ObjectInitType, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
-import { Application } from "egg";
-import { ModuleConfigUtil } from "@eggjs/tegg/helper";
-import { extend } from "extend2";
+import "../EggCompatibleProtoImpl-CPxLvSu4.js";
+import { ModuleConfigLoader } from "../ModuleConfigLoader-CvZLf99E.js";
 
-//#region src/lib/ModuleConfigLoader.ts
-var ModuleConfigLoader = class {
-	app;
-	constructor(app) {
-		this.app = app;
-	}
-	loadModuleConfigs(moduleConfigMap) {
-		const moduleConfigs = new ModuleConfigs(moduleConfigMap);
-		const func = function() {
-			return moduleConfigs;
-		};
-		const name = "moduleConfigs";
-		Object.defineProperty(func, "name", {
-			value: name,
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
-		PrototypeUtil.setIsEggPrototype(func);
-		PrototypeUtil.setFilePath(func, "mock_file_path");
-		PrototypeUtil.setProperty(func, {
-			name,
-			initType: ObjectInitType.SINGLETON,
-			accessLevel: AccessLevel.PUBLIC,
-			protoImplType: COMPATIBLE_PROTO_IMPLE_TYPE
-		});
-		QualifierUtil.addProtoQualifier(func, LoadUnitNameQualifierAttribute, "app");
-		QualifierUtil.addProtoQualifier(func, InitTypeQualifierAttribute, ObjectInitType.SINGLETON);
-		QualifierUtil.addProtoQualifier(func, EggQualifierAttribute, EggType.APP);
-		return func;
-	}
-	loadModuleConfigList() {
-		const result = [];
-		const moduleConfigMap = {};
-		for (const reference of this.app.moduleReferences) {
-			const moduleName = ModuleConfigUtil.readModuleNameSync(reference.path);
-			const defaultConfig = ModuleConfigUtil.loadModuleConfigSync(reference.path, void 0, this.app.config.env);
-			const config = extend(true, {}, defaultConfig, this.app.moduleConfigs[moduleName]?.config);
-			moduleConfigMap[moduleName] = {
-				name: moduleName,
-				reference: {
-					name: moduleName,
-					path: reference.path
-				},
-				config
-			};
-			const func = function() {
-				return config;
-			};
-			const name = "moduleConfig";
-			Object.defineProperty(func, "name", {
-				value: name,
-				writable: false,
-				enumerable: false,
-				configurable: true
-			});
-			PrototypeUtil.setIsEggPrototype(func);
-			PrototypeUtil.setFilePath(func, "mock_file_path");
-			PrototypeUtil.setProperty(func, {
-				name,
-				initType: ObjectInitType.SINGLETON,
-				accessLevel: AccessLevel.PUBLIC,
-				protoImplType: COMPATIBLE_PROTO_IMPLE_TYPE
-			});
-			QualifierUtil.addProtoQualifier(func, LoadUnitNameQualifierAttribute, "app");
-			QualifierUtil.addProtoQualifier(func, InitTypeQualifierAttribute, ObjectInitType.SINGLETON);
-			QualifierUtil.addProtoQualifier(func, EggQualifierAttribute, EggType.APP);
-			QualifierUtil.addProtoQualifier(func, ConfigSourceQualifierAttribute, moduleName);
-			result.push(func);
-		}
-		const moduleConfigs = this.loadModuleConfigs(moduleConfigMap);
-		result.push(moduleConfigs);
-		return result;
-	}
-};
-
-//#endregion
 export { ModuleConfigLoader };

package/dist/lib/ModuleHandler.d.ts

@@ -1,17 +1,2 @@
-import { LoadUnit } from "@eggjs/tegg-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);
-  init(): Promise<void>;
-  destroy(): Promise<void>;
-}
-//#endregion
+import { ModuleHandler } from "../ModuleHandler-Dyx7JGj-.js";
 export { ModuleHandler };

package/dist/lib/ModuleHandler.js

@@ -1,46 +1,8 @@
-import { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl.js";
-import { EggModuleLoader } from "./EggModuleLoader.js";
-import { CompatibleUtil } from "./CompatibleUtil.js";
-import { EggLoadUnitType, LoadUnitFactory } from "@eggjs/tegg-metadata";
-import { LoadUnitInstanceFactory } from "@eggjs/tegg-runtime";
-import { Base } from "sdk-base";
-import { Application, Context } from "egg";
+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";
 
-//#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);
-	}
-	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.js

@@ -1,33 +1,3 @@
-//#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()}`;
-}
+import { getCalleeFromStack } from "../Utils-11aRpnkd.js";
 
-//#endregion
 export { getCalleeFromStack };