@analogjs/vite-plugin-angular 3.0.0-alpha.35 → 3.0.0-alpha.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@analogjs/vite-plugin-angular",
-  "version": "3.0.0-alpha.35",
+  "version": "3.0.0-alpha.36",
   "description": "Vite Plugin for Angular",
   "type": "module",
   "keywords": [
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@analogjs/angular-compiler": "3.0.0-alpha.35",
+    "@analogjs/angular-compiler": "3.0.0-alpha.36",
     "es-toolkit": "^1.45.1",
     "obug": "^2.1.1",
     "oxc-parser": "^0.124.0",

package/src/lib/angular-vite-plugin.js

@@ -1,7 +1,7 @@
 import { angularFullVersion, cjt, createAngularCompilation, sourceFileCache } from "./utils/devkit.js";
 import { getJsTransformConfigKey, isRolldown } from "./utils/rolldown.js";
 import { buildOptimizerPlugin } from "./angular-build-optimizer-plugin.js";
-import { activateDeferredDebug, applyDebugOption, debugCompilationApi, debugCompiler, debugCompilerV, debugHmr, debugHmrV, debugStyles, debugStylesV, debugTailwind, debugTailwindV } from "./utils/debug.js";
+import { activateDeferredDebug, applyDebugOption, debugCompilationApi, debugCompiler, debugCompilerV, debugEmit, debugEmitV, debugHmr, debugHmrV, debugStyles, debugStylesV, debugTailwind, debugTailwindV } from "./utils/debug.js";
 import { inspectCssTailwindDirectives, isTailwindReferenceError, throwTailwindReferenceTextError } from "./utils/tailwind-reference.js";
 import { jitPlugin } from "./angular-jit-plugin.js";
 import { createCompilerPlugin, createRolldownCompilerPlugin } from "./compiler-plugin.js";
@@ -145,6 +145,7 @@ function angular(options) {
 	let builder;
 	let nextProgram;
 	const tsconfigOptionsCache = /* @__PURE__ */ new Map();
+	const tsconfigGraphRootCache = /* @__PURE__ */ new Map();
 	let cachedHost;
 	let cachedHostKey;
 	let includeCache = [];
@@ -153,6 +154,7 @@ function angular(options) {
 	}
 	function invalidateTsconfigCaches() {
 		tsconfigOptionsCache.clear();
+		tsconfigGraphRootCache.clear();
 		cachedHost = void 0;
 		cachedHostKey = void 0;
 	}
@@ -325,9 +327,36 @@ function angular(options) {
 	const templateUrlsResolver = new TemplateUrlsResolver();
 	let outputFile;
 	const outputFiles = /* @__PURE__ */ new Map();
+	const normalizeEmitterLookupId = (file) => {
+		const normalizedFile = normalizePath(file);
+		if (!normalizedFile.startsWith("/@fs/")) return normalizedFile;
+		return normalizePath(normalizedFile.slice(4).replace(/^\/([A-Za-z]:\/)/, "$1"));
+	};
+	const describeEmitMarkers = (content) => ({
+		contentLength: content.length,
+		hasCmp: content.includes("ɵcmp"),
+		hasFac: content.includes("ɵfac"),
+		hasProv: content.includes("ɵprov"),
+		hasDecorate: content.includes("__decorate"),
+		hasMetadata: content.includes("__metadata")
+	});
 	const fileEmitter = (file) => {
-		outputFile?.(file);
-		return outputFiles.get(normalizePath(file));
+		const normalizedFile = normalizeEmitterLookupId(file);
+		const hadCachedEmit = outputFiles.has(normalizedFile);
+		outputFile?.(normalizedFile);
+		const emittedResult = outputFiles.get(normalizedFile);
+		debugEmitV("fileEmitter lookup", {
+			requestFile: file,
+			normalizedFile,
+			hadCachedEmit,
+			hasOutputFileHook: !!outputFile,
+			emitted: !!emittedResult,
+			knownOutputCount: outputFiles.size,
+			contentLength: emittedResult?.content?.length ?? 0,
+			errorCount: emittedResult?.errors?.length ?? 0,
+			warningCount: emittedResult?.warnings?.length ?? 0
+		});
+		return emittedResult;
 	};
 	let initialCompilation = false;
 	const declarationFiles = [];
@@ -890,12 +919,27 @@ function angular(options) {
 					const typescriptResult = fileEmitter(id);
 					if (!typescriptResult) {
 						debugCompilerV("transform skip (file not emitted by Angular)", { id });
-						if (!id.includes("@ng/component") && /(Component|Directive|Pipe|Injectable|NgModule)\(/.test(code)) this.warn(`[@analogjs/vite-plugin-angular]: "${id}" contains Angular decorators but is not in the TypeScript program. Ensure it is included in your tsconfig.`);
+						const isAngular = !id.includes("@ng/component") && /(Component|Directive|Pipe|Injectable|NgModule)\(/.test(code);
+						debugEmit("transform emit miss", {
+							id,
+							normalizedId: normalizeEmitterLookupId(id),
+							knownOutputCount: outputFiles.size,
+							hasOutputFileHook: !!outputFile,
+							isAngular
+						});
+						if (isAngular) this.warn(`[@analogjs/vite-plugin-angular]: "${id}" contains Angular decorators but is not in the TypeScript program. Ensure it is included in your tsconfig.`);
 						return;
 					}
 					if (typescriptResult.warnings && typescriptResult.warnings.length > 0) this.warn(`${typescriptResult.warnings.join("\n")}`);
 					if (typescriptResult.errors && typescriptResult.errors.length > 0) this.error(`${typescriptResult.errors.join("\n")}`);
 					let data = typescriptResult.content ?? "";
+					debugEmitV("transform emit hit", {
+						id,
+						normalizedId: normalizeEmitterLookupId(id),
+						...describeEmitMarkers(data),
+						errorCount: typescriptResult.errors?.length ?? 0,
+						warningCount: typescriptResult.warnings?.length ?? 0
+					});
 					if (jit && data.includes("angular:jit:")) {
 						data = data.replace(/angular:jit:style:inline;/g, "virtual:angular:jit:style:inline;");
 						templateUrls.forEach((templateUrlSet) => {
@@ -1064,13 +1108,26 @@ function angular(options) {
 		nxFolderPlugin()
 	].filter(Boolean);
 	function findIncludes() {
-		return globSync(pluginOptions.include.map((glob) => normalizeIncludeGlob(pluginOptions.workspaceRoot, glob)), {
+		const globs = pluginOptions.include.map((glob) => normalizeIncludeGlob(pluginOptions.workspaceRoot, glob));
+		const files = globSync(globs, {
 			dot: true,
 			absolute: true
 		});
+		debugEmit("include discovery", {
+			patternCount: globs.length,
+			fileCount: files.length
+		});
+		debugEmitV("include discovery files", {
+			globs,
+			files: files.map((file) => normalizePath(file))
+		});
+		return files;
 	}
 	function ensureIncludeCache() {
-		if (pluginOptions.include.length > 0 && includeCache.length === 0) includeCache = findIncludes();
+		if (pluginOptions.include.length > 0 && includeCache.length === 0) {
+			includeCache = findIncludes();
+			debugEmit("include cache populated", { fileCount: includeCache.length });
+		}
 		return includeCache;
 	}
 	function getTsconfigCacheKey(resolvedTsConfigPath, config) {
@@ -1079,45 +1136,128 @@ function angular(options) {
 			config.mode === "production" ? "prod" : "dev",
 			isTest ? "test" : "app",
 			config.build?.lib ? "lib" : "nolib",
-			pluginOptions.hmr ? "hmr" : "nohmr",
+			pluginOptions.liveReload ? "live-reload" : "no-live-reload",
 			pluginOptions.hasTailwindCss ? "tw" : "notw"
 		].join("|");
 	}
-	function getCachedTsconfigOptions(resolvedTsConfigPath, config) {
+	function readAngularTsconfigConfiguration(resolvedTsConfigPath, config) {
 		const isProd = config.mode === "production";
+		return compilerCli.readConfiguration(resolvedTsConfigPath, {
+			suppressOutputPathCheck: true,
+			outDir: void 0,
+			sourceMap: false,
+			inlineSourceMap: !isProd,
+			inlineSources: !isProd,
+			declaration: false,
+			declarationMap: false,
+			allowEmptyCodegenFiles: false,
+			annotationsAs: "decorators",
+			enableResourceInlining: false,
+			noEmitOnError: false,
+			mapRoot: void 0,
+			sourceRoot: void 0,
+			supportTestBed: false,
+			supportJitMode: false
+		});
+	}
+	function getCachedTsconfigOptions(resolvedTsConfigPath, config) {
 		const tsconfigKey = getTsconfigCacheKey(resolvedTsConfigPath, config);
 		let cached = tsconfigOptionsCache.get(tsconfigKey);
 		if (!cached) {
-			const read = compilerCli.readConfiguration(resolvedTsConfigPath, {
-				suppressOutputPathCheck: true,
-				outDir: void 0,
-				sourceMap: false,
-				inlineSourceMap: !isProd,
-				inlineSources: !isProd,
-				declaration: false,
-				declarationMap: false,
-				allowEmptyCodegenFiles: false,
-				annotationsAs: "decorators",
-				enableResourceInlining: false,
-				noEmitOnError: false,
-				mapRoot: void 0,
-				sourceRoot: void 0,
-				supportTestBed: false,
-				supportJitMode: false
-			});
+			const read = readAngularTsconfigConfiguration(resolvedTsConfigPath, config);
 			cached = {
 				options: read.options,
 				rootNames: read.rootNames
 			};
 			tsconfigOptionsCache.set(tsconfigKey, cached);
+			debugEmit("tsconfig root names loaded", {
+				resolvedTsConfigPath,
+				rootNameCount: read.rootNames.length
+			});
+			debugEmitV("tsconfig root names", {
+				resolvedTsConfigPath,
+				rootNames: read.rootNames.map((file) => normalizePath(file))
+			});
 		}
 		return cached;
 	}
+	function resolveReferenceTsconfigPath(referencePath, ownerTsconfigPath) {
+		const ownerDir = dirname(ownerTsconfigPath);
+		const resolvedReference = normalizePath(isAbsolute(referencePath) ? referencePath : resolve(ownerDir, referencePath));
+		if (existsSync(resolvedReference)) {
+			try {
+				if (statSync(resolvedReference).isDirectory()) {
+					const nestedTsconfig = join(resolvedReference, "tsconfig.json");
+					return existsSync(nestedTsconfig) ? normalizePath(nestedTsconfig) : void 0;
+				}
+			} catch {
+				return;
+			}
+			return resolvedReference;
+		}
+		if (!resolvedReference.endsWith(".json")) {
+			const asJson = `${resolvedReference}.json`;
+			if (existsSync(asJson)) return normalizePath(asJson);
+			const nestedTsconfig = join(resolvedReference, "tsconfig.json");
+			if (existsSync(nestedTsconfig)) return normalizePath(nestedTsconfig);
+		}
+	}
+	function collectTsconfigPathRoots(resolvedTsConfigPath, options, rawTsconfig) {
+		const tsPaths = rawTsconfig.compilerOptions?.paths ?? options.paths;
+		if (!tsPaths) return [];
+		const tsconfigDir = dirname(resolvedTsConfigPath);
+		const configuredBaseUrl = typeof options.baseUrl === "string" ? options.baseUrl : typeof rawTsconfig.compilerOptions?.baseUrl === "string" ? rawTsconfig.compilerOptions.baseUrl : void 0;
+		const resolvedBaseUrl = configuredBaseUrl ? isAbsolute(configuredBaseUrl) ? configuredBaseUrl : resolve(tsconfigDir, configuredBaseUrl) : tsconfigDir;
+		const discoveredRoots = /* @__PURE__ */ new Set();
+		for (const targets of Object.values(tsPaths)) for (const target of targets) {
+			const resolvedTarget = normalizePath(isAbsolute(target) ? target : resolve(resolvedBaseUrl, target));
+			if (target.includes("*")) {
+				for (const match of globSync(resolvedTarget, {
+					dot: true,
+					absolute: true
+				})) discoveredRoots.add(normalizePath(match));
+				continue;
+			}
+			if (existsSync(resolvedTarget)) discoveredRoots.add(resolvedTarget);
+		}
+		return [...discoveredRoots];
+	}
+	function collectExpandedTsconfigRoots(resolvedTsConfigPath, config, visited = /* @__PURE__ */ new Set()) {
+		const normalizedTsConfigPath = normalizePath(resolvedTsConfigPath);
+		if (visited.has(normalizedTsConfigPath)) return [];
+		const tsconfigKey = `${getTsconfigCacheKey(normalizedTsConfigPath, config)}|graph`;
+		const cached = tsconfigGraphRootCache.get(tsconfigKey);
+		if (cached) return cached;
+		visited.add(normalizedTsConfigPath);
+		const read = readAngularTsconfigConfiguration(normalizedTsConfigPath, config);
+		const rawTsconfig = ts.readConfigFile(normalizedTsConfigPath, ts.sys.readFile).config ?? {};
+		const expandedRoots = new Set(read.rootNames.map((file) => normalizePath(file)));
+		const pathRoots = collectTsconfigPathRoots(normalizedTsConfigPath, read.options, rawTsconfig);
+		for (const pathRoot of pathRoots) expandedRoots.add(pathRoot);
+		const referenceConfigs = (rawTsconfig.references ?? []).flatMap((reference) => typeof reference.path === "string" ? [resolveReferenceTsconfigPath(reference.path, normalizedTsConfigPath)] : []).filter((reference) => !!reference);
+		for (const referenceConfig of referenceConfigs) for (const referenceRoot of collectExpandedTsconfigRoots(referenceConfig, config, visited)) expandedRoots.add(referenceRoot);
+		const expandedRootList = [...expandedRoots];
+		tsconfigGraphRootCache.set(tsconfigKey, expandedRootList);
+		debugEmit("expanded tsconfig graph roots", {
+			resolvedTsConfigPath: normalizedTsConfigPath,
+			directRootNameCount: read.rootNames.length,
+			pathRootCount: pathRoots.length,
+			referenceConfigCount: referenceConfigs.length,
+			expandedRootCount: expandedRootList.length
+		});
+		debugEmitV("expanded tsconfig graph root files", {
+			resolvedTsConfigPath: normalizedTsConfigPath,
+			pathRoots,
+			referenceConfigs,
+			rootNames: expandedRootList
+		});
+		return expandedRootList;
+	}
 	function resolveCompilationApiTsConfigPath(resolvedTsConfigPath, config) {
 		const includedFiles = ensureIncludeCache();
-		if (includedFiles.length === 0) return resolvedTsConfigPath;
 		const cached = getCachedTsconfigOptions(resolvedTsConfigPath, config);
-		const mergedRootNames = union(cached.rootNames, includedFiles).map((file) => normalizePath(file));
+		const expandedGraphRoots = collectExpandedTsconfigRoots(resolvedTsConfigPath, config);
+		const mergedRootNames = union(cached.rootNames, expandedGraphRoots, includedFiles).map((file) => normalizePath(file));
 		if (mergedRootNames.length === cached.rootNames.length) return resolvedTsConfigPath;
 		const wrapperDir = join(isAbsolute(config.cacheDir) ? config.cacheDir : resolve(config.root, config.cacheDir), "analog-angular", "compilation-api");
 		const rawTsconfig = ts.readConfigFile(resolvedTsConfigPath, ts.sys.readFile).config ?? {};
@@ -1135,6 +1275,19 @@ function angular(options) {
 			includeCount: includedFiles.length,
 			rootNameCount: mergedRootNames.length
 		});
+		debugEmit("wrapper tsconfig root merge", {
+			originalTsconfig: resolvedTsConfigPath,
+			wrapperTsconfig: wrapperPath,
+			baseRootNameCount: cached.rootNames.length,
+			expandedGraphRootCount: expandedGraphRoots.length,
+			includeCount: includedFiles.length,
+			mergedRootNameCount: mergedRootNames.length,
+			referenceCount: rawTsconfig.references?.length ?? 0
+		});
+		debugEmitV("wrapper tsconfig root names", {
+			wrapperTsconfig: wrapperPath,
+			rootNames: mergedRootNames
+		});
 		return wrapperPath;
 	}
 	function resolveTsConfigPath() {
@@ -1157,15 +1310,21 @@ function angular(options) {
 	*     file-level HMR metadata (`hmrUpdateCode`, `hmrEligible`, `classNames`).
 	*/
 	async function performAngularCompilation(config, ids) {
-		angularCompilation ??= await createAngularCompilation(!!pluginOptions.jit, false);
+		const compilation = angularCompilation ??= await createAngularCompilation(!!pluginOptions.jit, false);
 		const modifiedFiles = ids?.length ? new Set(ids.map((file) => normalizePath(file))) : void 0;
 		if (modifiedFiles?.size) sourceFileCache$1.invalidate(modifiedFiles);
-		if (modifiedFiles?.size && angularCompilation.update) {
+		if (modifiedFiles?.size && compilation.update) {
 			debugCompilationApi("incremental update", { files: [...modifiedFiles] });
-			await angularCompilation.update(modifiedFiles);
+			await compilation.update(modifiedFiles);
 		}
-		const compilationApiTsConfigPath = resolveCompilationApiTsConfigPath(resolveTsConfigPath(), config);
-		const compilationResult = await angularCompilation.initialize(compilationApiTsConfigPath, {
+		const resolvedTsConfigPath = resolveTsConfigPath();
+		const compilationApiTsConfigPath = resolveCompilationApiTsConfigPath(resolvedTsConfigPath, config);
+		debugEmit("compilation initialize", {
+			resolvedTsConfigPath,
+			compilationApiTsConfigPath,
+			modifiedFileCount: modifiedFiles?.size ?? 0
+		});
+		const compilationResult = await compilation.initialize(compilationApiTsConfigPath, {
 			fileReplacements: toAngularCompilationFileReplacements(pluginOptions.fileReplacements, pluginOptions.workspaceRoot),
 			modifiedFiles,
 			async transformStylesheet(data, containingFile, resourceFile, order, className) {
@@ -1246,7 +1405,6 @@ function angular(options) {
 				tsCompilerOptions["supportTestBed"] = true;
 				tsCompilerOptions["supportJitMode"] = true;
 			}
-			if (angularFullVersion >= 2e5) tsCompilerOptions["_enableSelectorless"] = true;
 			if (!isTest && config.build?.lib) {
 				tsCompilerOptions["declaration"] = true;
 				tsCompilerOptions["declarationMap"] = watchMode;
@@ -1266,7 +1424,7 @@ function angular(options) {
 			skipped: 0,
 			errors: 0
 		};
-		compilationResult.externalStylesheets?.forEach((value, key) => {
+		for (const [key, value] of compilationResult.externalStylesheets ?? []) {
 			preprocessStats.total++;
 			const angularHash = `${value}.css`;
 			stylesheetRegistry?.registerExternalRequest(angularHash, key);
@@ -1336,17 +1494,28 @@ function angular(options) {
 				filename: angularHash,
 				resolvedPath: key
 			});
-		});
+		}
 		debugStyles("external stylesheet preprocessing complete", preprocessStats);
-		const diagnostics = await angularCompilation.diagnoseFiles(pluginOptions.disableTypeChecking ? DiagnosticModes.All & ~DiagnosticModes.Semantic : DiagnosticModes.All);
+		const diagnostics = await compilation.diagnoseFiles(pluginOptions.disableTypeChecking ? DiagnosticModes.All & ~DiagnosticModes.Semantic : DiagnosticModes.All);
 		const errors = diagnostics.errors?.length ? diagnostics.errors : [];
 		const warnings = diagnostics.warnings?.length ? diagnostics.warnings : [];
+		debugEmit("compilation diagnostics", {
+			errorCount: errors.length,
+			warningCount: warnings.length
+		});
 		const templateUpdates = mapTemplateUpdatesToFiles(compilationResult.templateUpdates);
 		if (templateUpdates.size > 0) debugHmr("compilation API template updates", {
 			count: templateUpdates.size,
 			files: [...templateUpdates.keys()]
 		});
-		for (const file of await angularCompilation.emitAffectedFiles()) {
+		const affectedFiles = await compilation.emitAffectedFiles();
+		debugEmit("emitAffectedFiles summary", {
+			count: affectedFiles.length,
+			templateUpdateCount: templateUpdates.size,
+			knownOutputCountBefore: outputFiles.size
+		});
+		debugEmitV("emitAffectedFiles files", { files: affectedFiles.map((file) => normalizePath(file.filename)) });
+		for (const file of affectedFiles) {
 			const normalizedFilename = normalizePath(file.filename);
 			const templateUpdate = templateUpdates.get(normalizedFilename);
 			if (templateUpdate) classNames.set(normalizedFilename, templateUpdate.className);
@@ -1358,6 +1527,14 @@ function angular(options) {
 				hmrUpdateCode: templateUpdate?.code,
 				hmrEligible: !!templateUpdate?.code
 			});
+			debugEmitV("registered compilation API output", {
+				filename: normalizedFilename,
+				...describeEmitMarkers(file.contents),
+				hasTemplateUpdate: !!templateUpdate,
+				errorCount: errors.length,
+				warningCount: warnings.length,
+				knownOutputCount: outputFiles.size
+			});
 		}
 	}
 	async function performCompilation(config, ids) {
@@ -1406,7 +1583,6 @@ function angular(options) {
 			tsCompilerOptions["supportTestBed"] = true;
 			tsCompilerOptions["supportJitMode"] = true;
 		}
-		if (angularFullVersion >= 2e5) tsCompilerOptions["_enableSelectorless"] = true;
 		if (!isTest && config.build?.lib) {
 			tsCompilerOptions["declaration"] = true;
 			tsCompilerOptions["declarationMap"] = watchMode;
@@ -1481,6 +1657,14 @@ function angular(options) {
 				hmrUpdateCode: metadata.hmrUpdateCode,
 				hmrEligible: metadata.hmrEligible
 			});
+			debugEmitV("registered ngtsc output", {
+				filename,
+				...describeEmitMarkers(content),
+				errorCount: metadata.errors?.length ?? 0,
+				warningCount: metadata.warnings?.length ?? 0,
+				hmrEligible: !!metadata.hmrEligible,
+				knownOutputCount: outputFiles.size
+			});
 		};
 		const writeOutputFile = (id) => {
 			const sourceFile = builder.getSourceFile(id);