@eggjs/tegg-standalone 4.0.0-beta.4 → 4.0.0-beta.5

package/README.md

@@ -1,5 +1,17 @@
 # `@eggjs/tegg-standalone`
 
+[![NPM version][npm-image]][npm-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+[![npm download][download-image]][download-url]
+[![Node.js Version](https://img.shields.io/node/v/@eggjs/tegg-standalone.svg?style=flat)](https://nodejs.org/en/download/)
+
+[npm-image]: https://img.shields.io/npm/v/@eggjs/tegg-standalone.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@eggjs/tegg-standalone
+[snyk-image]: https://snyk.io/test/npm/@eggjs/tegg-standalone/badge.svg?style=flat-square
+[snyk-url]: https://snyk.io/test/npm/@eggjs/tegg-standalone
+[download-image]: https://img.shields.io/npm/dm/@eggjs/tegg-standalone.svg?style=flat-square
+[download-url]: https://npmjs.org/package/@eggjs/tegg-standalone
+
 通过 `@eggjs/tegg-standalone` 在一个独立环境去中运行 tegg 应用。
 
 ## install
@@ -12,7 +24,7 @@ npm i --save @eggjs/tegg-standalone
 当一个类上有 Runner 注解时，会自动运行其 main 函数。注无需再使用 `ContextProto` 注解，因为独立运行跑完即销毁，不用再区分独立上下文。
 
 ```ts
-import { Runner, MainRunner } from '@eggjs/tegg/standalone';
+import { Runner, type MainRunner } from '@eggjs/tegg/standalone';
 
 @Runner()
 @SingletonProto()

package/dist/ConfigSourceLoadUnitHook.js

@@ -0,0 +1,21 @@
+import "@eggjs/tegg-metadata";
+import { ConfigSourceQualifier, ConfigSourceQualifierAttribute, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
+
+//#region src/ConfigSourceLoadUnitHook.ts
+/**
+* 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 };

package/dist/EggModuleLoader.d.ts

@@ -0,0 +1,22 @@
+import { LoadUnit } from "@eggjs/tegg-metadata";
+import { ModuleReference } from "@eggjs/tegg-common-util";
+import { Logger } from "@eggjs/tegg";
+
+//#region src/EggModuleLoader.d.ts
+interface EggModuleLoaderOptions {
+  logger: Logger;
+  baseDir: string;
+  dump?: boolean;
+}
+declare class EggModuleLoader {
+  private moduleReferences;
+  private globalGraph;
+  private options;
+  constructor(moduleReferences: readonly ModuleReference[], options: EggModuleLoaderOptions);
+  init(): Promise<void>;
+  private static generateAppGraph;
+  load(): Promise<LoadUnit[]>;
+  static preLoad(moduleReferences: readonly ModuleReference[], options: EggModuleLoaderOptions): Promise<void>;
+}
+//#endregion
+export { EggModuleLoader, EggModuleLoaderOptions };

package/dist/EggModuleLoader.js

@@ -0,0 +1,54 @@
+import { EggLoadUnitType, GlobalGraph, LoadUnitFactory, ModuleDescriptorDumper } from "@eggjs/tegg-metadata";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+
+//#region src/EggModuleLoader.ts
+var EggModuleLoader = class EggModuleLoader {
+	moduleReferences;
+	globalGraph;
+	options;
+	constructor(moduleReferences, options) {
+		this.moduleReferences = moduleReferences;
+		this.options = options;
+	}
+	async init() {
+		GlobalGraph.instance = this.globalGraph = await EggModuleLoader.generateAppGraph(this.moduleReferences, this.options);
+	}
+	static async generateAppGraph(moduleReferences, options) {
+		const moduleDescriptors = await LoaderFactory.loadApp(moduleReferences);
+		if (options.dump !== false) for (const moduleDescriptor of moduleDescriptors) ModuleDescriptorDumper.dump(moduleDescriptor, { dumpDir: options.baseDir }).catch((e) => {
+			e.message = "dump module descriptor failed: " + e.message;
+			options.logger.warn(e);
+		});
+		return await GlobalGraph.create(moduleDescriptors);
+	}
+	async load() {
+		const loadUnits = [];
+		this.globalGraph.build();
+		this.globalGraph.sort();
+		const moduleConfigList = GlobalGraph.instance.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);
+			loadUnits.push(loadUnit);
+		}
+		return loadUnits;
+	}
+	static async preLoad(moduleReferences, options) {
+		const loadUnits = [];
+		const loaderCache = /* @__PURE__ */ new Map();
+		const globalGraph = GlobalGraph.instance = await EggModuleLoader.generateAppGraph(moduleReferences, options);
+		globalGraph.sort();
+		const moduleConfigList = globalGraph.moduleConfigList;
+		for (const moduleConfig of moduleConfigList) {
+			const modulePath = moduleConfig.path;
+			const loader = loaderCache.get(modulePath);
+			const loadUnit = await LoadUnitFactory.createPreloadLoadUnit(modulePath, EggLoadUnitType.MODULE, loader);
+			loadUnits.push(loadUnit);
+		}
+		for (const load of loadUnits) await load.preLoad?.();
+	}
+};
+
+//#endregion
+export { EggModuleLoader };

package/dist/Runner.d.ts

@@ -0,0 +1,54 @@
+import { InnerObject } from "./StandaloneLoadUnit.js";
+import { LoadUnit } from "@eggjs/tegg-metadata";
+import { ModuleReference, ReadModuleReferenceOptions } from "@eggjs/tegg-common-util";
+import { EggContext, LoadUnitInstance } from "@eggjs/tegg-runtime";
+import { ModuleConfigHolder } from "@eggjs/tegg";
+
+//#region src/Runner.d.ts
+interface ModuleDependency extends ReadModuleReferenceOptions {
+  baseDir: string;
+}
+interface RunnerOptions {
+  /**
+   * @deprecated
+   * use inner object handlers instead
+   */
+  innerObjects?: Record<string, object>;
+  env?: string;
+  name?: string;
+  innerObjectHandlers?: Record<string, InnerObject[]>;
+  dependencies?: (string | ModuleDependency)[];
+  dump?: boolean;
+}
+declare class Runner {
+  readonly cwd: string;
+  readonly moduleReferences: readonly ModuleReference[];
+  readonly moduleConfigs: Record<string, ModuleConfigHolder>;
+  readonly env?: string;
+  readonly name?: string;
+  readonly options?: RunnerOptions;
+  private loadUnitLoader;
+  private runnerProto;
+  private configSourceEggPrototypeHook;
+  private loadUnitMultiInstanceProtoHook;
+  private dalTableEggPrototypeHook;
+  private dalModuleLoadUnitHook;
+  private transactionPrototypeHook;
+  private crosscutAdviceFactory;
+  private loadUnitAopHook;
+  private eggPrototypeCrossCutHook;
+  private eggObjectAopHook;
+  loadUnits: LoadUnit[];
+  loadUnitInstances: LoadUnitInstance[];
+  innerObjects: Record<string, InnerObject[]>;
+  constructor(cwd: string, options?: RunnerOptions);
+  load(): Promise<LoadUnit[]>;
+  static getModuleReferences(cwd: string, dependencies?: RunnerOptions['dependencies']): readonly ModuleReference[];
+  static preLoad(cwd: string, dependencies?: RunnerOptions['dependencies']): Promise<void>;
+  private initLoaderInstance;
+  init(): Promise<void>;
+  run<T>(aCtx?: EggContext): Promise<T>;
+  destroy(): Promise<void>;
+}
+//#endregion
+export { ModuleDependency, Runner, RunnerOptions };

package/dist/Runner.js

@@ -0,0 +1,181 @@
+import { EggModuleLoader } from "./EggModuleLoader.js";
+import { StandaloneLoadUnit, StandaloneLoadUnitType } from "./StandaloneLoadUnit.js";
+import { StandaloneContext } from "./StandaloneContext.js";
+import { StandaloneContextHandler } from "./StandaloneContextHandler.js";
+import { ConfigSourceLoadUnitHook } from "./ConfigSourceLoadUnitHook.js";
+import { EggPrototypeLifecycleUtil, GlobalGraph, LoadUnitFactory, LoadUnitLifecycleUtil, LoadUnitMultiInstanceProtoHook } from "@eggjs/tegg-metadata";
+import { ModuleConfigUtil } from "@eggjs/tegg-common-util";
+import { ContextHandler, EggContainerFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, ModuleLoadUnitInstance } from "@eggjs/tegg-runtime";
+import { ConfigSourceQualifierAttribute, ModuleConfigs, PrototypeUtil } from "@eggjs/tegg";
+import { StandaloneUtil } from "@eggjs/tegg/standalone";
+import { CrosscutAdviceFactory } from "@eggjs/tegg/aop";
+import { EggObjectAopHook, EggPrototypeCrossCutHook, LoadUnitAopHook, crossCutGraphHook, pointCutGraphHook } from "@eggjs/tegg-aop-runtime";
+import { DalModuleLoadUnitHook, DalTableEggPrototypeHook, MysqlDataSourceManager, SqlMapManager, TableModelManager, TransactionPrototypeHook } from "@eggjs/tegg-dal-plugin";
+
+//#region src/Runner.ts
+var Runner = class Runner {
+	cwd;
+	moduleReferences;
+	moduleConfigs;
+	env;
+	name;
+	options;
+	loadUnitLoader;
+	runnerProto;
+	configSourceEggPrototypeHook;
+	loadUnitMultiInstanceProtoHook;
+	dalTableEggPrototypeHook;
+	dalModuleLoadUnitHook;
+	transactionPrototypeHook;
+	crosscutAdviceFactory;
+	loadUnitAopHook;
+	eggPrototypeCrossCutHook;
+	eggObjectAopHook;
+	loadUnits = [];
+	loadUnitInstances = [];
+	innerObjects;
+	constructor(cwd, options) {
+		this.cwd = cwd;
+		this.env = options?.env;
+		this.name = options?.name;
+		this.options = options;
+		this.moduleReferences = Runner.getModuleReferences(this.cwd, options?.dependencies);
+		this.moduleConfigs = {};
+		this.innerObjects = {
+			moduleConfigs: [{ obj: new ModuleConfigs(this.moduleConfigs) }],
+			moduleConfig: []
+		};
+		const runtimeConfig = {
+			baseDir: this.cwd,
+			name: this.name,
+			env: this.env
+		};
+		this.innerObjects.runtimeConfig = [{ obj: runtimeConfig }];
+		if (!ModuleConfigUtil.configNames) ModuleConfigUtil.configNames = ["module.default", `module.${this.env}`];
+		for (const reference of this.moduleReferences) {
+			const absoluteRef = {
+				path: ModuleConfigUtil.resolveModuleDir(reference.path, this.cwd),
+				name: reference.name
+			};
+			const moduleName = ModuleConfigUtil.readModuleNameSync(absoluteRef.path);
+			this.moduleConfigs[moduleName] = {
+				name: moduleName,
+				reference: absoluteRef,
+				config: ModuleConfigUtil.loadModuleConfigSync(absoluteRef.path)
+			};
+		}
+		for (const moduleConfig of Object.values(this.moduleConfigs)) this.innerObjects.moduleConfig.push({
+			obj: moduleConfig.config,
+			qualifiers: [{
+				attribute: ConfigSourceQualifierAttribute,
+				value: moduleConfig.name
+			}]
+		});
+		if (options?.innerObjects) for (const [name, obj] of Object.entries(options.innerObjects)) this.innerObjects[name] = [{ obj }];
+		else if (options?.innerObjectHandlers) Object.assign(this.innerObjects, options.innerObjectHandlers);
+	}
+	async load() {
+		StandaloneContextHandler.register();
+		LoadUnitFactory.registerLoadUnitCreator(StandaloneLoadUnitType, () => {
+			return new StandaloneLoadUnit(this.innerObjects);
+		});
+		LoadUnitInstanceFactory.registerLoadUnitInstanceClass(StandaloneLoadUnitType, ModuleLoadUnitInstance.createModuleLoadUnitInstance);
+		const standaloneLoadUnit = await LoadUnitFactory.createLoadUnit("MockStandaloneLoadUnitPath", StandaloneLoadUnitType, { async load() {
+			return [];
+		} });
+		const loadUnits = await this.loadUnitLoader.load();
+		return [standaloneLoadUnit, ...loadUnits];
+	}
+	static getModuleReferences(cwd, dependencies) {
+		return (dependencies || []).concat(cwd).reduce((list, baseDir) => {
+			const module = typeof baseDir === "string" ? { baseDir } : baseDir;
+			return list.concat(...ModuleConfigUtil.readModuleReference(module.baseDir, module));
+		}, []);
+	}
+	static async preLoad(cwd, dependencies) {
+		const moduleReferences = Runner.getModuleReferences(cwd, dependencies);
+		await EggModuleLoader.preLoad(moduleReferences, {
+			baseDir: cwd,
+			logger: console,
+			dump: false
+		});
+	}
+	async initLoaderInstance() {
+		this.loadUnitLoader = new EggModuleLoader(this.moduleReferences, {
+			logger: (this.innerObjects.logger && this.innerObjects.logger[0])?.obj || console,
+			baseDir: this.cwd,
+			dump: this.options?.dump
+		});
+		await this.loadUnitLoader.init();
+		GlobalGraph.instance.registerBuildHook(crossCutGraphHook);
+		GlobalGraph.instance.registerBuildHook(pointCutGraphHook);
+		const configSourceEggPrototypeHook = new ConfigSourceLoadUnitHook();
+		LoadUnitLifecycleUtil.registerLifecycle(configSourceEggPrototypeHook);
+		this.crosscutAdviceFactory = new CrosscutAdviceFactory();
+		this.loadUnitAopHook = new LoadUnitAopHook(this.crosscutAdviceFactory);
+		this.eggPrototypeCrossCutHook = new EggPrototypeCrossCutHook(this.crosscutAdviceFactory);
+		this.eggObjectAopHook = new EggObjectAopHook();
+		EggPrototypeLifecycleUtil.registerLifecycle(this.eggPrototypeCrossCutHook);
+		LoadUnitLifecycleUtil.registerLifecycle(this.loadUnitAopHook);
+		EggObjectLifecycleUtil.registerLifecycle(this.eggObjectAopHook);
+		this.loadUnitMultiInstanceProtoHook = new LoadUnitMultiInstanceProtoHook();
+		LoadUnitLifecycleUtil.registerLifecycle(this.loadUnitMultiInstanceProtoHook);
+		const logger = (this.innerObjects.logger && this.innerObjects.logger[0])?.obj || console;
+		this.dalModuleLoadUnitHook = new DalModuleLoadUnitHook(this.env ?? "", this.moduleConfigs, logger);
+		this.dalTableEggPrototypeHook = new DalTableEggPrototypeHook(logger);
+		this.transactionPrototypeHook = new TransactionPrototypeHook(this.moduleConfigs, logger);
+		EggPrototypeLifecycleUtil.registerLifecycle(this.dalTableEggPrototypeHook);
+		EggPrototypeLifecycleUtil.registerLifecycle(this.transactionPrototypeHook);
+		LoadUnitLifecycleUtil.registerLifecycle(this.dalModuleLoadUnitHook);
+	}
+	async init() {
+		await this.initLoaderInstance();
+		this.loadUnits = await this.load();
+		const instances = [];
+		for (const loadUnit of this.loadUnits) {
+			const instance = await LoadUnitInstanceFactory.createLoadUnitInstance(loadUnit);
+			instances.push(instance);
+		}
+		this.loadUnitInstances = instances;
+		const runnerClass = StandaloneUtil.getMainRunner();
+		if (!runnerClass) throw new Error("not found runner class. Do you add @Runner decorator?");
+		const proto = PrototypeUtil.getClazzProto(runnerClass);
+		if (!proto) throw new Error(`can not get proto for clazz ${runnerClass.name}`);
+		this.runnerProto = proto;
+	}
+	async run(aCtx) {
+		const lifecycle = {};
+		const ctx = aCtx || new StandaloneContext();
+		return await ContextHandler.run(ctx, async () => {
+			if (ctx.init) await ctx.init(lifecycle);
+			const runner = (await EggContainerFactory.getOrCreateEggObject(this.runnerProto)).obj;
+			try {
+				return await runner.main();
+			} finally {
+				if (ctx.destroy) ctx.destroy(lifecycle).catch((e) => {
+					e.message = `[tegg/standalone] destroy tegg context failed: ${e.message}`;
+					console.warn(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);
+		if (this.configSourceEggPrototypeHook) LoadUnitLifecycleUtil.deleteLifecycle(this.configSourceEggPrototypeHook);
+		if (this.eggPrototypeCrossCutHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.eggPrototypeCrossCutHook);
+		if (this.loadUnitAopHook) LoadUnitLifecycleUtil.deleteLifecycle(this.loadUnitAopHook);
+		if (this.eggObjectAopHook) EggObjectLifecycleUtil.deleteLifecycle(this.eggObjectAopHook);
+		if (this.loadUnitMultiInstanceProtoHook) LoadUnitLifecycleUtil.deleteLifecycle(this.loadUnitMultiInstanceProtoHook);
+		if (this.dalTableEggPrototypeHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.dalTableEggPrototypeHook);
+		if (this.dalModuleLoadUnitHook) LoadUnitLifecycleUtil.deleteLifecycle(this.dalModuleLoadUnitHook);
+		if (this.transactionPrototypeHook) EggPrototypeLifecycleUtil.deleteLifecycle(this.transactionPrototypeHook);
+		MysqlDataSourceManager.instance.clear();
+		SqlMapManager.instance.clear();
+		TableModelManager.instance.clear();
+		ModuleConfigUtil.setConfigNames(void 0);
+	}
+};
+
+//#endregion
+export { Runner };

package/dist/StandaloneContext.d.ts

@@ -0,0 +1,9 @@
+import { AbstractEggContext } from "@eggjs/tegg-runtime";
+
+//#region src/StandaloneContext.d.ts
+declare class StandaloneContext extends AbstractEggContext {
+  id: string;
+  constructor();
+}
+//#endregion
+export { StandaloneContext };

package/dist/StandaloneContext.js

@@ -0,0 +1,14 @@
+import { AbstractEggContext } from "@eggjs/tegg-runtime";
+import { IdenticalUtil } from "@eggjs/tegg-lifecycle";
+
+//#region src/StandaloneContext.ts
+var StandaloneContext = class extends AbstractEggContext {
+	id;
+	constructor() {
+		super();
+		this.id = IdenticalUtil.createContextId();
+	}
+};
+
+//#endregion
+export { StandaloneContext };

package/dist/StandaloneContextHandler.js

@@ -0,0 +1,18 @@
+import { ContextHandler } from "@eggjs/tegg-runtime";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/StandaloneContextHandler.ts
+var StandaloneContextHandler = class StandaloneContextHandler {
+	static storage = new AsyncLocalStorage();
+	static register() {
+		ContextHandler.getContextCallback = () => {
+			return StandaloneContextHandler.storage.getStore();
+		};
+		ContextHandler.runInContextCallback = (context, fn) => {
+			return StandaloneContextHandler.storage.run(context, fn);
+		};
+	}
+};
+
+//#endregion
+export { StandaloneContextHandler };

package/dist/StandaloneInnerObject.d.ts

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

package/dist/StandaloneInnerObject.js

@@ -0,0 +1,31 @@
+import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
+import "@eggjs/tegg-metadata";
+import { EggObjectFactory } from "@eggjs/tegg-runtime";
+import { IdenticalUtil } from "@eggjs/tegg";
+
+//#region src/StandaloneInnerObject.ts
+const OBJ = Symbol("EggCompatibleObject#obj");
+var StandaloneInnerObject = class StandaloneInnerObject {
+	isReady = true;
+	[OBJ];
+	proto;
+	name;
+	id;
+	constructor(name, proto) {
+		this.proto = proto;
+		this.name = name;
+		this.id = IdenticalUtil.createObjectId(this.proto.id);
+	}
+	get obj() {
+		if (!this[OBJ]) this[OBJ] = this.proto.constructEggObject();
+		return this[OBJ];
+	}
+	injectProperty() {}
+	static async createObject(name, proto) {
+		return new StandaloneInnerObject(name, proto);
+	}
+};
+EggObjectFactory.registerEggObjectCreateMethod(StandaloneInnerObjectProto, StandaloneInnerObject.createObject);
+
+//#endregion
+export { StandaloneInnerObject };

package/dist/StandaloneInnerObjectProto.d.ts

@@ -0,0 +1,24 @@
+import { EggPrototype, EggPrototypeLifecycleContext, InjectObjectProto } from "@eggjs/tegg-metadata";
+import { AccessLevel, EggProtoImplClass, EggPrototypeName, Id, MetaDataKey, ObjectInitTypeLike, QualifierInfo, QualifierValue } from "@eggjs/tegg";
+
+//#region src/StandaloneInnerObjectProto.d.ts
+declare class StandaloneInnerObjectProto 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;
+  constructEggObject(): object;
+  getMetaData<T>(metadataKey: MetaDataKey): T | undefined;
+  getQualifier(attribute: string): QualifierValue | undefined;
+  static create(ctx: EggPrototypeLifecycleContext): EggPrototype;
+}
+//#endregion
+export { StandaloneInnerObjectProto };

package/dist/StandaloneInnerObjectProto.js

@@ -0,0 +1,49 @@
+import "@eggjs/tegg-metadata";
+import { AccessLevel, IdenticalUtil, MetadataUtil, QualifierUtil } from "@eggjs/tegg";
+
+//#region src/StandaloneInnerObjectProto.ts
+var StandaloneInnerObjectProto = class StandaloneInnerObjectProto {
+	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;
+	}
+	constructEggObject() {
+		return Reflect.apply(this.clazz, null, []);
+	}
+	getMetaData(metadataKey) {
+		return MetadataUtil.getMetaData(metadataKey, this.clazz);
+	}
+	getQualifier(attribute) {
+		return this.qualifiers.find((t) => t.attribute === attribute)?.value;
+	}
+	static create(ctx) {
+		const { clazz, loadUnit } = ctx;
+		const name = ctx.prototypeInfo.name;
+		const id = IdenticalUtil.createProtoId(loadUnit.id, name);
+		return new StandaloneInnerObjectProto(id, name, clazz, ctx.prototypeInfo.initType, loadUnit.id, QualifierUtil.getProtoQualifiers(clazz));
+	}
+};
+
+//#endregion
+export { StandaloneInnerObjectProto };

package/dist/StandaloneLoadUnit.d.ts

@@ -0,0 +1,10 @@
+import { EggPrototype, LoadUnit } from "@eggjs/tegg-metadata";
+import { QualifierInfo } from "@eggjs/tegg";
+
+//#region src/StandaloneLoadUnit.d.ts
+interface InnerObject {
+  obj: object;
+  qualifiers?: QualifierInfo[];
+}
+//#endregion
+export { InnerObject };

package/dist/StandaloneLoadUnit.js

@@ -0,0 +1,54 @@
+import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
+import { EggPrototypeFactory } from "@eggjs/tegg-metadata";
+import { MapUtil } from "@eggjs/tegg-common-util";
+import { ObjectInitType } from "@eggjs/tegg";
+import { IdenticalUtil as IdenticalUtil$1 } from "@eggjs/tegg-lifecycle";
+
+//#region src/StandaloneLoadUnit.ts
+const StandaloneLoadUnitType = "StandaloneLoadUnitType";
+var StandaloneLoadUnit = class {
+	id = "StandaloneLoadUnit";
+	name = "StandaloneLoadUnit";
+	unitPath = "MockStandaloneLoadUnitPath";
+	type = StandaloneLoadUnitType;
+	innerObject;
+	protoMap = /* @__PURE__ */ new Map();
+	constructor(innerObject) {
+		this.innerObject = innerObject;
+	}
+	async init() {
+		for (const [name, objs] of Object.entries(this.innerObject)) for (const { obj, qualifiers } of objs) {
+			const proto = new StandaloneInnerObjectProto(IdenticalUtil$1.createProtoId(this.id, name), name, (() => obj), ObjectInitType.SINGLETON, this.id, qualifiers || []);
+			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 namedProtoMap of this.protoMap.values()) for (const proto of namedProtoMap.values()) 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();
+	}
+};
+
+//#endregion
+export { StandaloneLoadUnit, StandaloneLoadUnitType };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-export * from './src/EggModuleLoader.js';
-export * from './src/Runner.js';
-export * from './src/main.js';
-export * from './src/StandaloneInnerObjectProto.js';
-export * from './src/StandaloneContext.js';
-export * from './src/StandaloneInnerObject.js';
+import { EggModuleLoader, EggModuleLoaderOptions } from "./EggModuleLoader.js";
+import { ModuleDependency, Runner, RunnerOptions } from "./Runner.js";
+import { main, preLoad } from "./main.js";
+import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
+import { StandaloneContext } from "./StandaloneContext.js";
+import { StandaloneInnerObject } from "./StandaloneInnerObject.js";
+export { EggModuleLoader, EggModuleLoaderOptions, ModuleDependency, Runner, RunnerOptions, StandaloneContext, StandaloneInnerObject, StandaloneInnerObjectProto, main, preLoad };

package/dist/index.js

@@ -1,7 +1,8 @@
-export * from './src/EggModuleLoader.js';
-export * from './src/Runner.js';
-export * from './src/main.js';
-export * from './src/StandaloneInnerObjectProto.js';
-export * from './src/StandaloneContext.js';
-export * from './src/StandaloneInnerObject.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsZ0NBQWdDLENBQUMifQ==
+import { EggModuleLoader } from "./EggModuleLoader.js";
+import { StandaloneInnerObjectProto } from "./StandaloneInnerObjectProto.js";
+import { StandaloneContext } from "./StandaloneContext.js";
+import { Runner } from "./Runner.js";
+import { main, preLoad } from "./main.js";
+import { StandaloneInnerObject } from "./StandaloneInnerObject.js";
+
+export { EggModuleLoader, Runner, StandaloneContext, StandaloneInnerObject, StandaloneInnerObjectProto, main, preLoad };

package/dist/main.d.ts

@@ -0,0 +1,7 @@
+import { RunnerOptions } from "./Runner.js";
+
+//#region src/main.d.ts
+declare function preLoad(cwd: string, dependencies?: RunnerOptions['dependencies']): Promise<void>;
+declare function main<T = void>(cwd: string, options?: RunnerOptions): Promise<T>;
+//#endregion
+export { main, preLoad };