@eggjs/tegg-loader 4.0.2-beta.1 → 4.0.2-beta.10

package/dist/LoaderFactory.d.ts

@@ -1,13 +1,36 @@
 import { EggLoadUnitTypeLike, Loader, ModuleReference } from "@eggjs/tegg-types";
+import { LoaderFS } from "@eggjs/loader-fs";
 import { ModuleDescriptor } from "@eggjs/metadata";
 
 //#region src/LoaderFactory.d.ts
-type LoaderCreator = (unitPath: string) => Loader;
+type LoaderCreator = (unitPath: string, loaderFS?: LoaderFS) => Loader;
+interface ManifestModuleReference {
+  name: string;
+  path: string;
+  optional?: boolean;
+  loaderType?: string;
+}
+interface ManifestModuleDescriptor {
+  name: string;
+  unitPath: string;
+  optional?: boolean;
+  /** Files containing decorated classes, relative to unitPath */
+  decoratedFiles: string[];
+}
+/** Shape of the 'tegg' manifest extension stored via ManifestStore.setExtension() */
+interface TeggManifestExtension {
+  moduleReferences: ManifestModuleReference[];
+  moduleDescriptors: ManifestModuleDescriptor[];
+}
+declare const TEGG_MANIFEST_KEY = "tegg";
+interface LoadAppManifest {
+  moduleDescriptors: ManifestModuleDescriptor[];
+}
 declare class LoaderFactory {
   private static loaderCreatorMap;
-  static createLoader(unitPath: string, type: EggLoadUnitTypeLike): Loader;
+  static createLoader(unitPath: string, type: EggLoadUnitTypeLike, loaderFS?: LoaderFS): Loader;
   static registerLoader(type: EggLoadUnitTypeLike, creator: LoaderCreator): void;
-  static loadApp(moduleReferences: readonly ModuleReference[]): Promise<ModuleDescriptor[]>;
+  static loadApp(moduleReferences: readonly ModuleReference[], manifest?: LoadAppManifest, loaderFS?: LoaderFS): Promise<ModuleDescriptor[]>;
 }
 //#endregion
-export { LoaderCreator, LoaderFactory };
+export { LoadAppManifest, LoaderCreator, LoaderFactory, ManifestModuleDescriptor, ManifestModuleReference, TEGG_MANIFEST_KEY, TeggManifestExtension };

package/dist/LoaderFactory.js

@@ -2,21 +2,33 @@ import { PrototypeUtil } from "@eggjs/core-decorator";
 import { EggLoadUnitType } from "@eggjs/tegg-types";
 
 //#region src/LoaderFactory.ts
+const TEGG_MANIFEST_KEY = "tegg";
 var LoaderFactory = class LoaderFactory {
 	static loaderCreatorMap = /* @__PURE__ */ new Map();
-	static createLoader(unitPath, type) {
+	static createLoader(unitPath, type, loaderFS) {
 		const creator = this.loaderCreatorMap.get(type);
 		if (!creator) throw new Error(`not find creator for loader type ${type}`);
-		return creator(unitPath);
+		return creator(unitPath, loaderFS);
 	}
 	static registerLoader(type, creator) {
 		this.loaderCreatorMap.set(type, creator);
 	}
-	static async loadApp(moduleReferences) {
+	static async loadApp(moduleReferences, manifest, loaderFS) {
 		const result = [];
 		const multiInstanceClazzList = [];
+		const manifestMap = /* @__PURE__ */ new Map();
+		if (manifest?.moduleDescriptors) for (const desc of manifest.moduleDescriptors) manifestMap.set(desc.unitPath, desc);
+		let ModuleLoaderClass;
+		if (manifestMap.size > 0) ModuleLoaderClass = (await import("./impl/ModuleLoader.js")).ModuleLoader;
 		for (const moduleReference of moduleReferences) {
-			const loader = LoaderFactory.createLoader(moduleReference.path, moduleReference.loaderType || EggLoadUnitType.MODULE);
+			const manifestDesc = manifestMap.get(moduleReference.path);
+			const loaderType = moduleReference.loaderType || EggLoadUnitType.MODULE;
+			let loader;
+			if (manifestDesc && ModuleLoaderClass && loaderType === EggLoadUnitType.MODULE) loader = new ModuleLoaderClass(moduleReference.path, {
+				precomputedFiles: manifestDesc.decoratedFiles,
+				loaderFS
+			});
+			else loader = LoaderFactory.createLoader(moduleReference.path, loaderType, loaderFS);
 			const res = {
 				name: moduleReference.name,
 				unitPath: moduleReference.path,
@@ -35,4 +47,4 @@ var LoaderFactory = class LoaderFactory {
 };
 
 //#endregion
-export { LoaderFactory };
+export { LoaderFactory, TEGG_MANIFEST_KEY };

package/dist/LoaderUtil.js

@@ -5,6 +5,10 @@ import { isClass } from "is-type-of";
 
 //#region src/LoaderUtil.ts
 const Module = globalThis.module?.constructor?.length > 1 ? globalThis.module.constructor : BuiltinModule;
+function createLoadError(filePath, e) {
+	const message = e instanceof Error ? e.message : String(e);
+	return new Error(`[tegg/loader] load ${filePath} failed: ${message}`, { cause: e });
+}
 var LoaderUtil = class LoaderUtil {
 	static config = {};
 	static setConfig(config) {
@@ -12,7 +16,15 @@ var LoaderUtil = class LoaderUtil {
 	}
 	static supportExtensions() {
 		const extensions = Object.keys(Module._extensions);
-		if (process.env.VITEST === "true" && !extensions.includes(".ts")) extensions.push(".ts");
+		const nodeMajorVersion = parseInt(process.versions.node.split(".", 1)[0], 10);
+		if (process.env.EGG_TS_ENABLE !== "false" && (extensions.includes(".ts") || process.env.VITEST === "true" || process.env.EGG_TS_ENABLE === "true" || nodeMajorVersion >= 22)) {
+			for (const ext of [
+				".ts",
+				".mts",
+				".cts"
+			]) if (!extensions.includes(ext)) extensions.push(ext);
+		}
+		if (process.env.EGG_TS_ENABLE === "false") return extensions.filter((ext) => ext !== ".ts" && ext !== ".mts" && ext !== ".cts");
 		return extensions;
 	}
 	static get extension() {
@@ -30,20 +42,27 @@ var LoaderUtil = class LoaderUtil {
 		];
 	}
 	static async loadFile(filePath) {
-		if (process.platform === "win32") filePath = pathToFileURL(filePath).toString();
+		const originalFilePath = filePath;
 		let exports;
 		try {
-			exports = await import(filePath);
+			exports = globalThis.__EGG_BUNDLE_MODULE_LOADER__?.(originalFilePath.split("\\").join("/"));
 		} catch (e) {
-			console.trace("[tegg/loader] loadFile %s error:", filePath);
-			console.error(e);
-			throw new Error(`[tegg/loader] load ${filePath} failed: ${e.message}`, { cause: e });
+			throw createLoadError(originalFilePath, e);
+		}
+		if (exports == null) {
+			if (process.platform === "win32") filePath = pathToFileURL(filePath).toString();
+			try {
+				exports = await import(filePath);
+			} catch (e) {
+				throw createLoadError(filePath, e);
+			}
 		}
 		const clazzList = [];
 		const exportNames = Object.keys(exports);
 		for (const exportName of exportNames) {
 			const clazz = exports[exportName];
 			if (!(isClass(clazz) && (PrototypeUtil.isEggPrototype(clazz) || PrototypeUtil.isEggMultiInstancePrototype(clazz)))) continue;
+			PrototypeUtil.setFilePath(clazz, originalFilePath);
 			clazzList.push(clazz);
 		}
 		return clazzList;

package/dist/impl/ModuleLoader.d.ts

@@ -1,12 +1,21 @@
 import { EggProtoImplClass, Loader } from "@eggjs/tegg-types";
+import { LoaderFS } from "@eggjs/loader-fs";
 
 //#region src/impl/ModuleLoader.d.ts
+interface ModuleLoaderOptions {
+  /** Pre-computed file list from manifest (only decorated files) */
+  precomputedFiles?: string[];
+  /** File system abstraction used for discovery; manifest-backed in bundle mode */
+  loaderFS?: LoaderFS;
+}
 declare class ModuleLoader implements Loader {
   private readonly moduleDir;
   private protoClazzList;
-  constructor(moduleDir: string);
+  private readonly precomputedFiles?;
+  private readonly loaderFS;
+  constructor(moduleDir: string, options?: ModuleLoaderOptions);
   load(): Promise<EggProtoImplClass[]>;
-  static createModuleLoader(path: string): ModuleLoader;
+  static createModuleLoader(path: string, loaderFS?: LoaderFS): ModuleLoader;
 }
 //#endregion
-export { ModuleLoader };
+export { ModuleLoader, ModuleLoaderOptions };

package/dist/impl/ModuleLoader.js

@@ -2,22 +2,32 @@ import { LoaderFactory } from "../LoaderFactory.js";
 import { LoaderUtil } from "../LoaderUtil.js";
 import path from "node:path";
 import { debuglog } from "node:util";
-import globby from "globby";
+import { RealLoaderFS } from "@eggjs/loader-fs";
 
 //#region src/impl/ModuleLoader.ts
 const debug = debuglog("egg/tegg/loader/impl/ModuleLoader");
 var ModuleLoader = class ModuleLoader {
 	moduleDir;
 	protoClazzList;
-	constructor(moduleDir) {
+	precomputedFiles;
+	loaderFS;
+	constructor(moduleDir, options = {}) {
 		this.moduleDir = moduleDir;
+		this.precomputedFiles = options.precomputedFiles;
+		this.loaderFS = options.loaderFS ?? new RealLoaderFS();
 	}
 	async load() {
 		if (this.protoClazzList) return this.protoClazzList;
 		const protoClassList = [];
-		const filePattern = LoaderUtil.filePattern();
-		const files = await globby(filePattern, { cwd: this.moduleDir });
-		debug("load files: %o, filePattern: %o, moduleDir: %o", files, filePattern, this.moduleDir);
+		let files;
+		if (this.precomputedFiles) {
+			files = this.precomputedFiles;
+			debug("load from manifest, files: %o, moduleDir: %o", files, this.moduleDir);
+		} else {
+			const filePattern = LoaderUtil.filePattern();
+			files = this.loaderFS.glob(filePattern, { cwd: this.moduleDir });
+			debug("load files: %o, filePattern: %o, moduleDir: %o", files, filePattern, this.moduleDir);
+		}
 		for (const file of files) {
 			const realPath = path.join(this.moduleDir, file);
 			const fileClazzList = await LoaderUtil.loadFile(realPath);
@@ -26,8 +36,8 @@ var ModuleLoader = class ModuleLoader {
 		this.protoClazzList = Array.from(new Set(protoClassList));
 		return this.protoClazzList;
 	}
-	static createModuleLoader(path$1) {
-		return new ModuleLoader(path$1);
+	static createModuleLoader(path$1, loaderFS) {
+		return new ModuleLoader(path$1, { loaderFS });
 	}
 };
 LoaderFactory.registerLoader("MODULE", ModuleLoader.createModuleLoader);

package/dist/impl/index.d.ts

@@ -1 +1 @@
-import { ModuleLoader } from "./ModuleLoader.js";
+import { ModuleLoader, ModuleLoaderOptions } from "./ModuleLoader.js";

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { LoaderCreator, LoaderFactory } from "./LoaderFactory.js";
+import { LoadAppManifest, LoaderCreator, LoaderFactory, ManifestModuleDescriptor, ManifestModuleReference, TEGG_MANIFEST_KEY, TeggManifestExtension } from "./LoaderFactory.js";
 import { LoaderUtil } from "./LoaderUtil.js";
-import { ModuleLoader } from "./impl/ModuleLoader.js";
+import { ModuleLoader, ModuleLoaderOptions } from "./impl/ModuleLoader.js";
 import "./impl/index.js";
-export { LoaderCreator, LoaderFactory, LoaderUtil, ModuleLoader };
+export { LoadAppManifest, LoaderCreator, LoaderFactory, LoaderUtil, ManifestModuleDescriptor, ManifestModuleReference, ModuleLoader, ModuleLoaderOptions, TEGG_MANIFEST_KEY, TeggManifestExtension };

package/dist/index.js

@@ -1,6 +1,6 @@
-import { LoaderFactory } from "./LoaderFactory.js";
+import { LoaderFactory, TEGG_MANIFEST_KEY } from "./LoaderFactory.js";
 import { LoaderUtil } from "./LoaderUtil.js";
 import { ModuleLoader } from "./impl/ModuleLoader.js";
 import "./impl/index.js";
 
-export { LoaderFactory, LoaderUtil, ModuleLoader };
+export { LoaderFactory, LoaderUtil, ModuleLoader, TEGG_MANIFEST_KEY };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/tegg-loader",
-  "version": "4.0.2-beta.1",
+  "version": "4.0.2-beta.10",
   "description": "tegg default loader implement",
   "keywords": [
     "egg",
@@ -34,11 +34,12 @@
     "access": "public"
   },
   "dependencies": {
-    "globby": "^11.0.2",
     "is-type-of": "^2.2.0",
-    "@eggjs/core-decorator": "4.0.2-beta.1",
-    "@eggjs/tegg-types": "4.0.2-beta.1",
-    "@eggjs/metadata": "4.0.2-beta.1"
+    "@eggjs/loader-fs": "1.0.0-beta.10",
+    "@eggjs/typings": "4.1.2-beta.10",
+    "@eggjs/tegg-types": "4.0.2-beta.10",
+    "@eggjs/metadata": "4.0.2-beta.10",
+    "@eggjs/core-decorator": "4.0.2-beta.10"
   },
   "devDependencies": {
     "@types/node": "^24.10.2",