@eggjs/tegg-runtime 4.0.0-beta.3 → 4.0.0-beta.5

package/dist/impl/EggObjectUtil.js

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,73 @@
+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

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

@@ -0,0 +1,17 @@
+import { AbstractEggContext } from "./model/AbstractEggContext.js";
+import { ContextHandler } from "./model/ContextHandler.js";
+import { EggContextLifecycleUtil } from "./model/EggContext.js";
+import { EggObjectLifecycleUtil } from "./model/EggObject.js";
+import { LoadUnitInstanceLifecycleUtil } from "./model/LoadUnitInstance.js";
+import { ContextInitiator } from "./impl/ContextInitiator.js";
+import { ContextObjectGraph } from "./impl/ContextObjectGraph.js";
+import { EggAlwaysNewObjectContainer } from "./impl/EggAlwaysNewObjectContainer.js";
+import { EggObjectImpl } from "./impl/EggObjectImpl.js";
+import { EggObjectUtil } from "./impl/EggObjectUtil.js";
+import { ModuleLoadUnitInstance } from "./impl/ModuleLoadUnitInstance.js";
+import { EggContainerFactory } from "./factory/EggContainerFactory.js";
+import { EggObjectFactory } from "./factory/EggObjectFactory.js";
+import { LoadUnitInstanceFactory } from "./factory/LoadUnitInstanceFactory.js";
+import { EggRuntimeContext as EggContext } from "@eggjs/tegg-types/runtime";
+export * from "@eggjs/tegg-types/runtime";
+export { AbstractEggContext, ContextHandler, ContextInitiator, ContextObjectGraph, EggAlwaysNewObjectContainer, EggContainerFactory, type EggContext, EggContextLifecycleUtil, EggObjectFactory, EggObjectImpl, EggObjectLifecycleUtil, EggObjectUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil, ModuleLoadUnitInstance };

package/dist/index.js

@@ -0,0 +1,21 @@
+import { EggContainerFactory } from "./factory/EggContainerFactory.js";
+import { ContextObjectGraph } from "./impl/ContextObjectGraph.js";
+import { ContextInitiator } from "./impl/ContextInitiator.js";
+import { EggAlwaysNewObjectContainer } from "./impl/EggAlwaysNewObjectContainer.js";
+import { EggObjectUtil } from "./impl/EggObjectUtil.js";
+import { EggObjectImpl } from "./impl/EggObjectImpl.js";
+import { LoadUnitInstanceLifecycleUtil } from "./model/LoadUnitInstance.js";
+import { LoadUnitInstanceFactory } from "./factory/LoadUnitInstanceFactory.js";
+import { ModuleLoadUnitInstance } from "./impl/ModuleLoadUnitInstance.js";
+import "./impl/index.js";
+import { EggObjectFactory } from "./factory/EggObjectFactory.js";
+import "./factory/index.js";
+import { ContextHandler } from "./model/ContextHandler.js";
+import { EggContextLifecycleUtil } from "./model/EggContext.js";
+import { AbstractEggContext } from "./model/AbstractEggContext.js";
+import { EggObjectLifecycleUtil } from "./model/EggObject.js";
+import "./model/index.js";
+
+export * from "@eggjs/tegg-types/runtime"
+
+export { AbstractEggContext, ContextHandler, ContextInitiator, ContextObjectGraph, EggAlwaysNewObjectContainer, EggContainerFactory, EggContextLifecycleUtil, EggObjectFactory, EggObjectImpl, EggObjectLifecycleUtil, EggObjectUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil, ModuleLoadUnitInstance };

package/dist/model/AbstractEggContext.d.ts

@@ -0,0 +1,22 @@
+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 };

package/dist/model/AbstractEggContext.js

@@ -0,0 +1,83 @@
+import { EggContainerFactory } from "../factory/EggContainerFactory.js";
+import { EggObjectFactory } from "../factory/EggObjectFactory.js";
+import "../factory/index.js";
+import { ContextHandler } from "./ContextHandler.js";
+import { EggContextLifecycleUtil } from "./EggContext.js";
+import { debuglog } from "node:util";
+import { ObjectInitType } from "@eggjs/tegg-types";
+import { TeggError } from "@eggjs/tegg-metadata";
+import { MapUtil } from "@eggjs/tegg-common-util";
+
+//#region src/model/AbstractEggContext.ts
+const debug = debuglog("tegg/core/runtime/AbstractEggContext");
+var AbstractEggContext = class {
+	contextData = /* @__PURE__ */ new Map();
+	protoToCreate = /* @__PURE__ */ new Map();
+	eggObjectMap = /* @__PURE__ */ new Map();
+	eggObjectPromiseMap = /* @__PURE__ */ new Map();
+	destroyed = false;
+	addProtoToCreate(name, proto) {
+		this.protoToCreate.set(name, proto);
+	}
+	deleteProtoToCreate(name) {
+		this.protoToCreate.delete(name);
+	}
+	async destroy(ctx) {
+		await EggContextLifecycleUtil.objectPreDestroy(ctx, this);
+		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);
+		}));
+		this.contextData.clear();
+		this.destroyed = true;
+		await EggContextLifecycleUtil.clearObjectLifecycle(this);
+	}
+	get(key) {
+		return this.contextData.get(key);
+	}
+	getEggObject(name, proto) {
+		if (this.destroyed) throw TeggError.create(`Can not read property \`${String(name)}\` because egg ctx has been destroyed`, "read_after_ctx_destroyed");
+		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);
+	}
+	async getOrCreateEggObject(name, 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);
+				if (!protoObjPromiseMap.size) this.eggObjectPromiseMap.delete(proto.id);
+				protoObjMap.set(name, obj);
+			} else await protoObjPromiseMap.get(name);
+		}
+		return protoObjMap.get(name);
+	}
+	async init(ctx) {
+		await EggContextLifecycleUtil.objectPreCreate(ctx, this);
+		for (const [name, proto] of this.protoToCreate) await this.getOrCreateEggObject(name, proto);
+		await EggContextLifecycleUtil.objectPostCreate(ctx, this);
+	}
+	iterateProtoToCreate() {
+		return this.protoToCreate.entries();
+	}
+	set(key, val) {
+		this.contextData.set(key, val);
+	}
+};
+EggContainerFactory.registerContainerGetMethod(ObjectInitType.CONTEXT, () => {
+	const ctx = ContextHandler.getContext();
+	if (!ctx) {
+		debug("can not get teggCtx from ContextHandler");
+		throw new Error("ctx is required");
+	}
+	return ctx;
+});
+
+//#endregion
+export { AbstractEggContext };

package/dist/model/ContextHandler.d.ts

@@ -0,0 +1,12 @@
+import { EggRuntimeContext } from "@eggjs/tegg-types";
+
+//#region src/model/ContextHandler.d.ts
+type runInContextCallback<R = any> = (context: EggRuntimeContext, fn: () => Promise<R>) => Promise<R>;
+declare class ContextHandler {
+  static getContextCallback: () => EggRuntimeContext | undefined;
+  static runInContextCallback: runInContextCallback;
+  static getContext(): EggRuntimeContext | undefined;
+  static run<R = any>(context: EggRuntimeContext, fn: () => Promise<R>): Promise<R>;
+}
+//#endregion
+export { ContextHandler };

package/dist/model/ContextHandler.js

@@ -0,0 +1,18 @@
+import assert from "node:assert";
+
+//#region src/model/ContextHandler.ts
+var ContextHandler = class {
+	static getContextCallback;
+	static runInContextCallback;
+	static getContext() {
+		assert(this.getContextCallback, "getContextCallback not set");
+		return this.getContextCallback ? this.getContextCallback() : void 0;
+	}
+	static run(context, fn) {
+		assert(this.runInContextCallback, "runInContextCallback not set");
+		return this.runInContextCallback(context, fn);
+	}
+};
+
+//#endregion
+export { ContextHandler };

package/dist/model/EggContext.d.ts

@@ -0,0 +1,7 @@
+import { EggContextLifecycleContext, EggRuntimeContext } from "@eggjs/tegg-types";
+import { LifecycleUtil } from "@eggjs/tegg-lifecycle";
+
+//#region src/model/EggContext.d.ts
+declare const EggContextLifecycleUtil: LifecycleUtil<EggContextLifecycleContext, EggRuntimeContext>;
+//#endregion
+export { EggContextLifecycleUtil };

package/dist/model/EggContext.js

@@ -0,0 +1,7 @@
+import { LifecycleUtil } from "@eggjs/tegg-lifecycle";
+
+//#region src/model/EggContext.ts
+const EggContextLifecycleUtil = new LifecycleUtil();
+
+//#endregion
+export { EggContextLifecycleUtil };

package/dist/model/EggObject.d.ts

@@ -0,0 +1,7 @@
+import { EggObject, EggObjectLifeCycleContext } from "@eggjs/tegg-types";
+import { LifecycleUtil } from "@eggjs/tegg-lifecycle";
+
+//#region src/model/EggObject.d.ts
+declare const EggObjectLifecycleUtil: LifecycleUtil<EggObjectLifeCycleContext, EggObject>;
+//#endregion
+export { EggObjectLifecycleUtil };

package/dist/model/EggObject.js

@@ -0,0 +1,7 @@
+import { LifecycleUtil } from "@eggjs/tegg-lifecycle";
+
+//#region src/model/EggObject.ts
+const EggObjectLifecycleUtil = new LifecycleUtil();
+
+//#endregion
+export { EggObjectLifecycleUtil };

package/dist/model/LoadUnitInstance.d.ts

@@ -0,0 +1,7 @@
+import { LoadUnitInstance, LoadUnitInstanceLifecycleContext } from "@eggjs/tegg-types";
+import { LifecycleUtil } from "@eggjs/tegg-lifecycle";
+
+//#region src/model/LoadUnitInstance.d.ts
+declare const LoadUnitInstanceLifecycleUtil: LifecycleUtil<LoadUnitInstanceLifecycleContext, LoadUnitInstance>;
+//#endregion
+export { LoadUnitInstanceLifecycleUtil };

package/dist/model/LoadUnitInstance.js

@@ -0,0 +1,7 @@
+import { LifecycleUtil } from "@eggjs/tegg-lifecycle";
+
+//#region src/model/LoadUnitInstance.ts
+const LoadUnitInstanceLifecycleUtil = new LifecycleUtil();
+
+//#endregion
+export { LoadUnitInstanceLifecycleUtil };

package/dist/model/index.js

@@ -0,0 +1,7 @@
+import { LoadUnitInstanceLifecycleUtil } from "./LoadUnitInstance.js";
+import { ContextHandler } from "./ContextHandler.js";
+import { EggContextLifecycleUtil } from "./EggContext.js";
+import { AbstractEggContext } from "./AbstractEggContext.js";
+import { EggObjectLifecycleUtil } from "./EggObject.js";
+
+export {  };

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "@eggjs/tegg-runtime",
-  "version": "4.0.0-beta.3",
+  "version": "4.0.0-beta.5",
   "description": "tegg runtime",
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./src/index.d.ts",
-      "default": "./src/index.js"
-    }
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
   },
   "files": [
-    "src/**/*.js",
-    "src/**/*.d.ts"
+    "dist"
   ],
   "keywords": [
     "egg",
@@ -19,15 +16,9 @@
     "runtime",
     "tegg"
   ],
-  "scripts": {
-    "clean": "tsc -b --clean",
-    "tsc": "npm run clean && tsc -p ./tsconfig.json",
-    "tsc:pub": "npm run tsc",
-    "prepublishOnly": "npm run tsc"
-  },
   "author": "killagu <killa123@126.com>",
   "license": "MIT",
-  "homepage": "https://github.com/eggjs/tegg",
+  "homepage": "https://github.com/eggjs/tegg/tree/next/core/runtime",
   "bugs": {
     "url": "https://github.com/eggjs/tegg/issues"
   },
@@ -37,23 +28,32 @@
     "directory": "core/runtime"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.18.0"
   },
   "dependencies": {
-    "@eggjs/core-decorator": "^4.0.0-beta.3",
-    "@eggjs/tegg-common-util": "^4.0.0-beta.3",
-    "@eggjs/tegg-lifecycle": "^4.0.0-beta.3",
-    "@eggjs/tegg-metadata": "^4.0.0-beta.3",
-    "@eggjs/tegg-types": "^4.0.0-beta.3"
+    "@eggjs/core-decorator": "4.0.0-beta.5",
+    "@eggjs/tegg-lifecycle": "4.0.0-beta.5",
+    "@eggjs/tegg-metadata": "4.0.0-beta.5",
+    "@eggjs/tegg-common-util": "4.0.0-beta.5",
+    "@eggjs/tegg-types": "4.0.0-beta.5"
   },
   "devDependencies": {
-    "@eggjs/tegg-loader": "^4.0.0-beta.3",
-    "@types/node": "22",
-    "ts-node": "10",
-    "typescript": "5"
+    "@types/node": "^22.10.5",
+    "typescript": "^5.9.3",
+    "tsdown": "^0.15.6",
+    "unplugin-unused": "^0.5.3",
+    "@eggjs/module-test-util": "4.0.0-beta.4",
+    "@eggjs/tegg-loader": "4.0.0-beta.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6b84b0275fd728a4973746a5341236fe0481a33e"
-}
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/factory/EggContainerFactory.d.ts

@@ -1,26 +0,0 @@
-import type { ContainerGetMethod, EggContainer, EggObject, EggObjectName, EggProtoImplClass, EggPrototype, LifecycleContext, ObjectInitTypeLike, QualifierInfo } from '@eggjs/tegg-types';
-export declare class EggContainerFactory {
-    private static containerGetMethodMap;
-    private static ContextInitiatorClass;
-    static registerContainerGetMethod(initType: ObjectInitTypeLike, method: ContainerGetMethod): void;
-    static getContainer(proto: EggPrototype): EggContainer<LifecycleContext>;
-    /**
-     * get or create egg object
-     * If get singleton egg object in context,
-     * will create context egg object for it.
-     */
-    static getOrCreateEggObject(proto: EggPrototype, name?: EggObjectName): Promise<EggObject>;
-    /**
-     * get or create egg object from the Class
-     * If get singleton egg object in context,
-     * will create context egg object for it.
-     */
-    static getOrCreateEggObjectFromClazz(clazz: EggProtoImplClass, name?: EggObjectName, qualifiers?: QualifierInfo[]): Promise<EggObject>;
-    /**
-     * get or create egg object from the Name
-     * If get singleton egg object in context,
-     * will create context egg object for it.
-     */
-    static getOrCreateEggObjectFromName(name: EggObjectName, qualifiers?: QualifierInfo[]): Promise<EggObject>;
-    static getEggObject(proto: EggPrototype, name?: EggObjectName): EggObject;
-}