@eggjs/core-decorator 4.0.0-beta.8 → 4.0.1-beta.0

package/dist/util/PrototypeUtil.d.ts

@@ -0,0 +1,112 @@
+import { EggMultiInstanceCallbackPrototypeInfo, EggMultiInstancePrototypeInfo, EggProtoImplClass, EggPrototypeInfo, EggPrototypeName, InjectConstructorInfo, InjectObjectInfo, InjectType, MultiInstancePrototypeGetObjectsContext, MultiInstanceType, QualifierAttribute } from "@eggjs/tegg-types";
+
+//#region src/util/PrototypeUtil.d.ts
+declare class PrototypeUtil {
+  static readonly IS_EGG_OBJECT_PROTOTYPE: symbol;
+  static readonly IS_EGG_OBJECT_MULTI_INSTANCE_PROTOTYPE: symbol;
+  static readonly FILE_PATH: symbol;
+  static readonly PROTOTYPE_PROPERTY: symbol;
+  static readonly MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY: symbol;
+  static readonly MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY: symbol;
+  static readonly INJECT_OBJECT_NAME_SET: symbol;
+  static readonly INJECT_TYPE: symbol;
+  static readonly INJECT_CONSTRUCTOR_NAME_SET: symbol;
+  static readonly CLAZZ_PROTO: symbol;
+  static readonly MULTI_INSTANCE_CONSTRUCTOR_INDEX: symbol;
+  static readonly MULTI_INSTANCE_CONSTRUCTOR_ATTRIBUTES: symbol;
+  /**
+  * Mark class is egg object prototype
+  * @param {Function} clazz -
+  */
+  static setIsEggPrototype(clazz: EggProtoImplClass): void;
+  /**
+  * If class is egg object prototype, return true
+  * @param {Function} clazz -
+  */
+  static isEggPrototype(clazz: EggProtoImplClass): boolean;
+  /**
+  * Mark class is egg object multi instance prototype
+  * @param {Function} clazz -
+  */
+  static setIsEggMultiInstancePrototype(clazz: EggProtoImplClass): void;
+  /**
+  * If class is egg object multi instance prototype, return true
+  * @param {Function} clazz -
+  */
+  static isEggMultiInstancePrototype(clazz: EggProtoImplClass): boolean;
+  /**
+  * Get the type of the egg multi-instance prototype.
+  * @param {Function} clazz -
+  */
+  static getEggMultiInstancePrototypeType(clazz: EggProtoImplClass): MultiInstanceType | undefined;
+  /**
+  * set class file path
+  * @param {Function} clazz -
+  * @param {string} filePath -
+  */
+  static setFilePath(clazz: EggProtoImplClass, filePath: string): void;
+  /**
+  * get class file path
+  * @param {Function} clazz -
+  */
+  static getFilePath(clazz: EggProtoImplClass): string | undefined;
+  /**
+  * set class property
+  * @param {EggProtoImplClass} clazz -
+  * @param {EggPrototypeInfo} property -
+  */
+  static setProperty(clazz: EggProtoImplClass, property: EggPrototypeInfo): void;
+  /**
+  * get class property
+  * @param {EggProtoImplClass} clazz -
+  * @return {EggPrototypeInfo} -
+  */
+  static getProperty(clazz: EggProtoImplClass): EggPrototypeInfo | undefined;
+  static getInitType(clazz: EggProtoImplClass, ctx: MultiInstancePrototypeGetObjectsContext): Promise<string | undefined>;
+  static getAccessLevel(clazz: EggProtoImplClass, ctx: MultiInstancePrototypeGetObjectsContext): Promise<string | undefined>;
+  static getObjNames(clazz: EggProtoImplClass, ctx: MultiInstancePrototypeGetObjectsContext): Promise<EggPrototypeName[]>;
+  /**
+  * set class property
+  * @param {EggProtoImplClass} clazz -
+  * @param {EggPrototypeInfo} property -
+  */
+  static setMultiInstanceStaticProperty(clazz: EggProtoImplClass, property: EggMultiInstancePrototypeInfo): void;
+  /**
+  * set class property
+  * @param {EggProtoImplClass} clazz -
+  * @param {EggPrototypeInfo} property -
+  */
+  static setMultiInstanceCallbackProperty(clazz: EggProtoImplClass, property: EggMultiInstanceCallbackPrototypeInfo): void;
+  /**
+  * Get instance property of Static multi-instance prototype.
+  * @param {EggProtoImplClass} clazz -
+  */
+  static getStaticMultiInstanceProperty(clazz: EggProtoImplClass): EggMultiInstancePrototypeInfo | undefined;
+  /**
+  * Get instance property of Dynamic multi-instance prototype.
+  * @param {EggProtoImplClass} clazz -
+  * @param {MultiInstancePrototypeGetObjectsContext} ctx -
+  */
+  static getDynamicMultiInstanceProperty(clazz: EggProtoImplClass, ctx: MultiInstancePrototypeGetObjectsContext): Promise<EggMultiInstancePrototypeInfo | undefined>;
+  /**
+  * get class property
+  * @param {EggProtoImplClass} clazz -
+  * @param {MultiInstancePrototypeGetObjectsContext} ctx -
+  */
+  static getMultiInstanceProperty(clazz: EggProtoImplClass, ctx: MultiInstancePrototypeGetObjectsContext): Promise<EggMultiInstancePrototypeInfo | undefined>;
+  static setMultiInstanceConstructorAttributes(clazz: EggProtoImplClass, attributes: QualifierAttribute[]): void;
+  static getMultiInstanceConstructorAttributes(clazz: EggProtoImplClass): QualifierAttribute[];
+  static setMultiInstanceConstructorIndex(clazz: EggProtoImplClass, index: number): void;
+  static getMultiInstanceConstructorIndex(clazz: EggProtoImplClass): number | undefined;
+  static setInjectType(clazz: EggProtoImplClass, type: InjectType): void;
+  static addInjectObject(clazz: EggProtoImplClass, injectObject: InjectObjectInfo): void;
+  static addInjectConstructor(clazz: EggProtoImplClass, injectConstructorInfo: InjectConstructorInfo): void;
+  static getInjectType(clazz: EggProtoImplClass): InjectType | undefined;
+  static getInjectObjects(clazz: EggProtoImplClass): Array<InjectObjectInfo | InjectConstructorInfo>;
+  static getClazzProto(clazz: EggProtoImplClass): object | undefined;
+  static setClazzProto(clazz: EggProtoImplClass, proto: object): void;
+  static getDesignType(clazz: EggProtoImplClass, propKey?: PropertyKey): unknown | undefined;
+  static getDesignParamtypes(clazz: EggProtoImplClass, propKey?: PropertyKey): unknown[] | undefined;
+}
+//#endregion
+export { PrototypeUtil };

package/dist/util/PrototypeUtil.js

@@ -0,0 +1,216 @@
+import { MetadataUtil } from "./MetadataUtil.js";
+import { InitTypeQualifierAttribute, InjectType, LoadUnitNameQualifierAttribute, MultiInstanceType } from "@eggjs/tegg-types";
+
+//#region src/util/PrototypeUtil.ts
+var PrototypeUtil = class PrototypeUtil {
+	static IS_EGG_OBJECT_PROTOTYPE = Symbol.for("EggPrototype#isEggPrototype");
+	static IS_EGG_OBJECT_MULTI_INSTANCE_PROTOTYPE = Symbol.for("EggPrototype#isEggMultiInstancePrototype");
+	static FILE_PATH = Symbol.for("EggPrototype.filePath");
+	static PROTOTYPE_PROPERTY = Symbol.for("EggPrototype.Property");
+	static MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY = Symbol.for("EggPrototype.MultiInstanceStaticProperty");
+	static MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY = Symbol.for("EggPrototype.MultiInstanceCallbackProperty");
+	static INJECT_OBJECT_NAME_SET = Symbol.for("EggPrototype.injectObjectNames");
+	static INJECT_TYPE = Symbol.for("EggPrototype.injectType");
+	static INJECT_CONSTRUCTOR_NAME_SET = Symbol.for("EggPrototype.injectConstructorNames");
+	static CLAZZ_PROTO = Symbol.for("EggPrototype.clazzProto");
+	static MULTI_INSTANCE_CONSTRUCTOR_INDEX = Symbol.for("EggPrototype#multiInstanceConstructorIndex");
+	static MULTI_INSTANCE_CONSTRUCTOR_ATTRIBUTES = Symbol.for("EggPrototype#multiInstanceConstructorAttributes");
+	/**
+	* Mark class is egg object prototype
+	* @param {Function} clazz -
+	*/
+	static setIsEggPrototype(clazz) {
+		MetadataUtil.defineMetaData(PrototypeUtil.IS_EGG_OBJECT_PROTOTYPE, true, clazz);
+	}
+	/**
+	* If class is egg object prototype, return true
+	* @param {Function} clazz -
+	*/
+	static isEggPrototype(clazz) {
+		return MetadataUtil.getOwnBooleanMetaData(PrototypeUtil.IS_EGG_OBJECT_PROTOTYPE, clazz);
+	}
+	/**
+	* Mark class is egg object multi instance prototype
+	* @param {Function} clazz -
+	*/
+	static setIsEggMultiInstancePrototype(clazz) {
+		MetadataUtil.defineMetaData(PrototypeUtil.IS_EGG_OBJECT_MULTI_INSTANCE_PROTOTYPE, true, clazz);
+	}
+	/**
+	* If class is egg object multi instance prototype, return true
+	* @param {Function} clazz -
+	*/
+	static isEggMultiInstancePrototype(clazz) {
+		return MetadataUtil.getOwnBooleanMetaData(PrototypeUtil.IS_EGG_OBJECT_MULTI_INSTANCE_PROTOTYPE, clazz);
+	}
+	/**
+	* Get the type of the egg multi-instance prototype.
+	* @param {Function} clazz -
+	*/
+	static getEggMultiInstancePrototypeType(clazz) {
+		if (!PrototypeUtil.isEggMultiInstancePrototype(clazz)) return;
+		if (MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY, clazz)) return MultiInstanceType.STATIC;
+		return MultiInstanceType.DYNAMIC;
+	}
+	/**
+	* set class file path
+	* @param {Function} clazz -
+	* @param {string} filePath -
+	*/
+	static setFilePath(clazz, filePath) {
+		MetadataUtil.defineMetaData(PrototypeUtil.FILE_PATH, filePath, clazz);
+	}
+	/**
+	* get class file path
+	* @param {Function} clazz -
+	*/
+	static getFilePath(clazz) {
+		return MetadataUtil.getOwnMetaData(PrototypeUtil.FILE_PATH, clazz);
+	}
+	/**
+	* set class property
+	* @param {EggProtoImplClass} clazz -
+	* @param {EggPrototypeInfo} property -
+	*/
+	static setProperty(clazz, property) {
+		MetadataUtil.defineMetaData(PrototypeUtil.PROTOTYPE_PROPERTY, property, clazz);
+	}
+	/**
+	* get class property
+	* @param {EggProtoImplClass} clazz -
+	* @return {EggPrototypeInfo} -
+	*/
+	static getProperty(clazz) {
+		return MetadataUtil.getOwnMetaData(PrototypeUtil.PROTOTYPE_PROPERTY, clazz);
+	}
+	static async getInitType(clazz, ctx) {
+		return (PrototypeUtil.getProperty(clazz) ?? await PrototypeUtil.getMultiInstanceProperty(clazz, ctx))?.initType;
+	}
+	static async getAccessLevel(clazz, ctx) {
+		return (PrototypeUtil.getProperty(clazz) ?? await PrototypeUtil.getMultiInstanceProperty(clazz, ctx))?.accessLevel;
+	}
+	static async getObjNames(clazz, ctx) {
+		const property = PrototypeUtil.getProperty(clazz);
+		if (property) return [property.name];
+		return (await PrototypeUtil.getMultiInstanceProperty(clazz, ctx))?.objects.map((t) => t.name) || [];
+	}
+	/**
+	* set class property
+	* @param {EggProtoImplClass} clazz -
+	* @param {EggPrototypeInfo} property -
+	*/
+	static setMultiInstanceStaticProperty(clazz, property) {
+		MetadataUtil.defineMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY, property, clazz);
+	}
+	/**
+	* set class property
+	* @param {EggProtoImplClass} clazz -
+	* @param {EggPrototypeInfo} property -
+	*/
+	static setMultiInstanceCallbackProperty(clazz, property) {
+		MetadataUtil.defineMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY, property, clazz);
+	}
+	/**
+	* Get instance property of Static multi-instance prototype.
+	* @param {EggProtoImplClass} clazz -
+	*/
+	static getStaticMultiInstanceProperty(clazz) {
+		const metadata = MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY, clazz);
+		if (metadata) return metadata;
+	}
+	/**
+	* Get instance property of Dynamic multi-instance prototype.
+	* @param {EggProtoImplClass} clazz -
+	* @param {MultiInstancePrototypeGetObjectsContext} ctx -
+	*/
+	static async getDynamicMultiInstanceProperty(clazz, ctx) {
+		const callBackMetadata = MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY, clazz);
+		if (callBackMetadata) {
+			const objects = await callBackMetadata.getObjects(ctx);
+			return {
+				...callBackMetadata,
+				objects
+			};
+		}
+	}
+	/**
+	* get class property
+	* @param {EggProtoImplClass} clazz -
+	* @param {MultiInstancePrototypeGetObjectsContext} ctx -
+	*/
+	static async getMultiInstanceProperty(clazz, ctx) {
+		const metadata = MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY, clazz);
+		if (metadata) return metadata;
+		const callBackMetadata = MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY, clazz);
+		if (callBackMetadata) {
+			const objects = await callBackMetadata.getObjects(ctx);
+			const defaultQualifier = [{
+				attribute: InitTypeQualifierAttribute,
+				value: callBackMetadata.initType
+			}, {
+				attribute: LoadUnitNameQualifierAttribute,
+				value: ctx.moduleName
+			}];
+			for (const object of objects) defaultQualifier.forEach((qualifier) => {
+				if (!object.qualifiers.find((t) => t.attribute === qualifier.attribute)) object.qualifiers.push(qualifier);
+			});
+			return {
+				...callBackMetadata,
+				objects
+			};
+		}
+	}
+	static setMultiInstanceConstructorAttributes(clazz, attributes) {
+		MetadataUtil.defineMetaData(PrototypeUtil.MULTI_INSTANCE_CONSTRUCTOR_ATTRIBUTES, attributes, clazz);
+	}
+	static getMultiInstanceConstructorAttributes(clazz) {
+		return MetadataUtil.getMetaData(PrototypeUtil.MULTI_INSTANCE_CONSTRUCTOR_ATTRIBUTES, clazz) || [];
+	}
+	static setMultiInstanceConstructorIndex(clazz, index) {
+		MetadataUtil.defineMetaData(PrototypeUtil.MULTI_INSTANCE_CONSTRUCTOR_INDEX, index, clazz);
+	}
+	static getMultiInstanceConstructorIndex(clazz) {
+		return MetadataUtil.getMetaData(PrototypeUtil.MULTI_INSTANCE_CONSTRUCTOR_INDEX, clazz);
+	}
+	static setInjectType(clazz, type) {
+		const injectType = MetadataUtil.getMetaData(PrototypeUtil.INJECT_TYPE, clazz);
+		if (!injectType) MetadataUtil.defineMetaData(PrototypeUtil.INJECT_TYPE, type, clazz);
+		else if (injectType !== type) throw new Error(`class ${clazz.name} already use inject type ${injectType} can not use ${type}`);
+	}
+	static addInjectObject(clazz, injectObject) {
+		const objs = MetadataUtil.initOwnArrayMetaData(PrototypeUtil.INJECT_OBJECT_NAME_SET, clazz, []);
+		objs.push(injectObject);
+		MetadataUtil.defineMetaData(PrototypeUtil.INJECT_OBJECT_NAME_SET, objs, clazz);
+	}
+	static addInjectConstructor(clazz, injectConstructorInfo) {
+		const objs = MetadataUtil.initArrayMetaData(PrototypeUtil.INJECT_CONSTRUCTOR_NAME_SET, clazz, []);
+		objs.push(injectConstructorInfo);
+		MetadataUtil.defineMetaData(PrototypeUtil.INJECT_CONSTRUCTOR_NAME_SET, objs, clazz);
+	}
+	static getInjectType(clazz) {
+		return MetadataUtil.getMetaData(PrototypeUtil.INJECT_TYPE, clazz);
+	}
+	static getInjectObjects(clazz) {
+		const injectType = MetadataUtil.getMetaData(PrototypeUtil.INJECT_TYPE, clazz);
+		if (!injectType) return [];
+		if (injectType === InjectType.CONSTRUCTOR) return MetadataUtil.getArrayMetaData(PrototypeUtil.INJECT_CONSTRUCTOR_NAME_SET, clazz).sort((a, b) => {
+			return a.refIndex - b.refIndex;
+		});
+		return MetadataUtil.getArrayMetaData(PrototypeUtil.INJECT_OBJECT_NAME_SET, clazz);
+	}
+	static getClazzProto(clazz) {
+		return MetadataUtil.getMetaData(PrototypeUtil.CLAZZ_PROTO, clazz);
+	}
+	static setClazzProto(clazz, proto) {
+		MetadataUtil.defineMetaData(PrototypeUtil.CLAZZ_PROTO, proto, clazz);
+	}
+	static getDesignType(clazz, propKey) {
+		return MetadataUtil.getMetaData("design:type", clazz, propKey);
+	}
+	static getDesignParamtypes(clazz, propKey) {
+		return MetadataUtil.getMetaData("design:paramtypes", clazz, propKey);
+	}
+};
+
+//#endregion
+export { PrototypeUtil };

package/dist/util/QualifierUtil.d.ts

@@ -0,0 +1,17 @@
+import { EggProtoImplClass, QualifierAttribute, QualifierInfo, QualifierValue } from "@eggjs/tegg-types";
+
+//#region src/util/QualifierUtil.d.ts
+declare class QualifierUtil {
+  static addProtoQualifier(clazz: EggProtoImplClass, attribute: QualifierAttribute, value: QualifierValue, isForceReplacement?: boolean): void;
+  static getProtoQualifiers(clazz: EggProtoImplClass): QualifierInfo[];
+  static addInjectQualifier(clazz: EggProtoImplClass, property: PropertyKey | undefined, parameterIndex: number | undefined, attribute: QualifierAttribute, value: QualifierValue): void;
+  static addProperQualifier(clazz: EggProtoImplClass, property: PropertyKey, attribute: QualifierAttribute, value: QualifierValue): void;
+  static getProperQualifiers(clazz: EggProtoImplClass, property: PropertyKey): QualifierInfo[];
+  static getQualifierValue(clazz: EggProtoImplClass, attribute: QualifierAttribute): QualifierValue | undefined;
+  static getProperQualifier(clazz: EggProtoImplClass, property: PropertyKey, attribute: QualifierAttribute): QualifierValue | undefined;
+  static matchQualifiers(clazzQualifiers: QualifierInfo[], requestQualifiers: QualifierInfo[]): boolean;
+  static equalQualifiers(clazzQualifiers: QualifierInfo[], requestQualifiers: QualifierInfo[]): boolean;
+  static mergeQualifiers(...qualifiers: QualifierInfo[][]): QualifierInfo[];
+}
+//#endregion
+export { QualifierUtil };

package/dist/util/QualifierUtil.js

@@ -0,0 +1,68 @@
+import { MetadataUtil } from "./MetadataUtil.js";
+import { PROPERTY_QUALIFIER_META_DATA, QUALIFIER_META_DATA } from "@eggjs/tegg-types";
+import { MapUtil, ObjectUtils } from "@eggjs/tegg-common-util";
+
+//#region src/util/QualifierUtil.ts
+var QualifierUtil = class QualifierUtil {
+	static addProtoQualifier(clazz, attribute, value, isForceReplacement) {
+		if (QualifierUtil.getQualifierValue(clazz, attribute) && !isForceReplacement) throw new Error(`Qualifier Error: clazz ${clazz.name} attribute ${attribute.toString()} has been implemented`);
+		MetadataUtil.initOwnMapMetaData(QUALIFIER_META_DATA, clazz, /* @__PURE__ */ new Map()).set(attribute, value);
+	}
+	static getProtoQualifiers(clazz) {
+		const qualifiers = MetadataUtil.getMetaData(QUALIFIER_META_DATA, clazz);
+		if (!qualifiers) return [];
+		const res = [];
+		for (const [attribute, value] of qualifiers) res.push({
+			attribute,
+			value
+		});
+		return res;
+	}
+	static addInjectQualifier(clazz, property, parameterIndex, attribute, value) {
+		if (typeof parameterIndex === "number") {
+			const argName = ObjectUtils.getConstructorArgNameList(clazz)[parameterIndex];
+			QualifierUtil.addProperQualifier(clazz, argName, attribute, value);
+		} else QualifierUtil.addProperQualifier(clazz.constructor, property, attribute, value);
+	}
+	static addProperQualifier(clazz, property, attribute, value) {
+		const properQualifiers = MetadataUtil.initOwnMapMetaData(PROPERTY_QUALIFIER_META_DATA, clazz, /* @__PURE__ */ new Map());
+		MapUtil.getOrStore(properQualifiers, property, /* @__PURE__ */ new Map()).set(attribute, value);
+	}
+	static getProperQualifiers(clazz, property) {
+		const qualifiers = MetadataUtil.getMetaData(PROPERTY_QUALIFIER_META_DATA, clazz)?.get(property);
+		if (!qualifiers) return [];
+		const res = [];
+		for (const [attribute, value] of qualifiers) res.push({
+			attribute,
+			value
+		});
+		return res;
+	}
+	static getQualifierValue(clazz, attribute) {
+		return MetadataUtil.getMetaData(QUALIFIER_META_DATA, clazz)?.get(attribute);
+	}
+	static getProperQualifier(clazz, property, attribute) {
+		return (MetadataUtil.getMetaData(PROPERTY_QUALIFIER_META_DATA, clazz)?.get(property))?.get(attribute);
+	}
+	static matchQualifiers(clazzQualifiers, requestQualifiers) {
+		for (const request of requestQualifiers) if (!clazzQualifiers.find((t) => t.attribute === request.attribute && t.value === request.value)) return false;
+		return true;
+	}
+	static equalQualifiers(clazzQualifiers, requestQualifiers) {
+		if (clazzQualifiers.length !== requestQualifiers.length) return false;
+		return QualifierUtil.matchQualifiers(clazzQualifiers, requestQualifiers);
+	}
+	static mergeQualifiers(...qualifiers) {
+		const result = [];
+		const temp = {};
+		for (const qualifierList of qualifiers) for (const { attribute, value } of qualifierList) temp[attribute] = value;
+		for (const key of Reflect.ownKeys(temp)) result.push({
+			attribute: key,
+			value: temp[key]
+		});
+		return result;
+	}
+};
+
+//#endregion
+export { QualifierUtil };

package/dist/util/index.d.ts

@@ -0,0 +1,3 @@
+import { MetadataUtil } from "./MetadataUtil.js";
+import { PrototypeUtil } from "./PrototypeUtil.js";
+import { QualifierUtil } from "./QualifierUtil.js";

package/dist/util/index.js

@@ -0,0 +1,5 @@
+import { MetadataUtil } from "./MetadataUtil.js";
+import { PrototypeUtil } from "./PrototypeUtil.js";
+import { QualifierUtil } from "./QualifierUtil.js";
+
+export {  };

package/package.json

@@ -1,54 +1,50 @@
 {
   "name": "@eggjs/core-decorator",
-  "version": "4.0.0-beta.8",
+  "version": "4.0.1-beta.0",
   "description": "tegg core decorator",
   "keywords": [
-    "egg",
-    "typescript",
     "decorator",
-    "tegg"
-  ],
-  "type": "module",
-  "exports": {
-    ".": "./dist/index.js",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist"
+    "egg",
+    "tegg",
+    "typescript"
   ],
-  "author": "killagu <killa123@126.com>",
-  "license": "MIT",
-  "homepage": "https://github.com/eggjs/tegg/tree/next/core/core-decorator",
+  "homepage": "https://github.com/eggjs/egg/tree/next/tegg/core/core-decorator",
   "bugs": {
-    "url": "https://github.com/eggjs/tegg/issues"
+    "url": "https://github.com/eggjs/egg/issues"
   },
+  "license": "MIT",
+  "author": "killagu <killa123@126.com>",
   "repository": {
     "type": "git",
-    "url": "git@github.com:eggjs/tegg.git",
-    "directory": "core/core-decorator"
+    "url": "git+https://github.com/eggjs/egg.git",
+    "directory": "tegg/core/core-decorator"
   },
-  "engines": {
-    "node": ">=22.18.0"
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@eggjs/tegg-common-util": "4.0.0-beta.8",
-    "@eggjs/tegg-types": "4.0.0-beta.8"
+    "@eggjs/tegg-common-util": "4.0.1-beta.0",
+    "@eggjs/tegg-types": "4.0.1-beta.0"
   },
   "devDependencies": {
-    "@types/node": "^22.10.5",
-    "typescript": "^5.9.3",
-    "tsdown": "^0.15.6",
-    "unplugin-unused": "^0.5.3"
+    "@types/node": "^24.10.2",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=22.18.0"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "scripts": {
-    "clean": "rimraf dist",
-    "build": "tsdown",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsgo --noEmit"
   }
 }