@analogjs/vite-plugin-angular 3.0.0-alpha.9 → 3.0.0-alpha.90

package/src/lib/compiler/dts-reader.d.ts

@@ -0,0 +1,45 @@
+import { parseSync } from "oxc-parser";
+import { RegistryEntry } from "./registry.js";
+/**
+* Scan a single .d.ts file and extract Angular directive/component/pipe
+* metadata from the static ɵdir / ɵcmp / ɵpipe type declarations.
+*
+* This mirrors what ngtsc's DtsMetadataReader does: it reads the type
+* parameters of ɵɵDirectiveDeclaration / ɵɵComponentDeclaration /
+* ɵɵPipeDeclaration to discover selectors, inputs, and outputs for
+* pre-compiled Angular packages.
+*/
+export declare function scanDtsFile(code: string, fileName: string): RegistryEntry[];
+/**
+* Resolve a package's directory in node_modules, scan all its .d.ts files,
+* and return RegistryEntry[] for every Angular declaration found.
+*
+* @param packageName  e.g. "@angular/router"
+* @param basePath     project root (where node_modules lives)
+*/
+export declare function scanPackageDts(packageName: string, basePath: string, visited?: Set<string>): RegistryEntry[];
+/**
+* Parse a source file with OXC and return the set of bare-specifier package
+* names it imports (e.g. "@angular/router", "rxjs"). Relative imports are
+* skipped.
+*/
+export declare function collectImportedPackages(code: string, fileName: string, program?: ReturnType<typeof parseSync>["program"]): Set<string>;
+/**
+* Parse a source file with OXC and return the relative-path specifiers it
+* re-exports via `export * from './x'`, `export * as Ns from './x'`, or
+* `export { … } from './x'`. Bare-specifier re-exports are skipped.
+*
+* Used by the analog Vite plugin to walk library entry barrels at startup
+* (e.g. `helm/select/src/index.ts` → `./lib/hlm-select`) so the underlying
+* directive classes land in the registry before any consumer is compiled.
+*/
+export declare function collectRelativeReExports(code: string, fileName: string, program?: ReturnType<typeof parseSync>["program"]): string[];
+/**
+* Parse a source file with OXC and return every module specifier it imports or
+* re-exports from (relative AND bare), including `import`, `export * from`, and
+* `export { … } from`. Used to walk the transitive import graph at startup so
+* the registry contains components/directives/pipes/modules from files not
+* directly listed in tsconfig `files`/`include` (transitively-imported app
+* sources) or behind wildcard `paths` (workspace libraries).
+*/
+export declare function collectAllImports(code: string, fileName: string, program?: ReturnType<typeof parseSync>["program"]): string[];

package/src/lib/compiler/dts-reader.js

@@ -0,0 +1,395 @@
+import * as fs from "node:fs";
+import * as path$1 from "node:path";
+import { parseSync } from "oxc-parser";
+//#region packages/vite-plugin-angular/src/lib/compiler/dts-reader.ts
+/**
+* Scan a single .d.ts file and extract Angular directive/component/pipe
+* metadata from the static ɵdir / ɵcmp / ɵpipe type declarations.
+*
+* This mirrors what ngtsc's DtsMetadataReader does: it reads the type
+* parameters of ɵɵDirectiveDeclaration / ɵɵComponentDeclaration /
+* ɵɵPipeDeclaration to discover selectors, inputs, and outputs for
+* pre-compiled Angular packages.
+*/
+function scanDtsFile(code, fileName) {
+	if (!code.includes("DirectiveDeclaration") && !code.includes("ComponentDeclaration") && !code.includes("PipeDeclaration") && !code.includes("NgModuleDeclaration")) return [];
+	const { program } = parseSync(fileName, code);
+	const entries = [];
+	visitStatements(program.body, fileName, entries);
+	return entries;
+}
+/**
+* Resolve a package's directory in node_modules, scan all its .d.ts files,
+* and return RegistryEntry[] for every Angular declaration found.
+*
+* @param packageName  e.g. "@angular/router"
+* @param basePath     project root (where node_modules lives)
+*/
+function scanPackageDts(packageName, basePath, visited) {
+	let pkgDir = "";
+	let searchBase = basePath;
+	while (searchBase !== path$1.dirname(searchBase)) {
+		const candidate = path$1.join(searchBase, "node_modules", packageName);
+		if (fs.existsSync(candidate)) {
+			pkgDir = candidate;
+			break;
+		}
+		searchBase = path$1.dirname(searchBase);
+	}
+	if (!pkgDir) return [];
+	const classToImportPath = buildClassToImportMap(packageName, pkgDir);
+	const typesDir = path$1.join(pkgDir, "types");
+	const dtsFiles = collectDtsFiles(fs.existsSync(typesDir) ? typesDir : pkgDir);
+	const entries = [];
+	const referencedPackages = /* @__PURE__ */ new Set();
+	for (const file of dtsFiles) try {
+		const code = fs.readFileSync(file, "utf-8");
+		const fileEntries = scanDtsFile(code, file);
+		for (const entry of fileEntries) entry.sourcePackage = classToImportPath.get(entry.className) || subEntryFromFilePath(packageName, pkgDir, file) || packageName;
+		entries.push(...fileEntries);
+		if (visited && fileEntries.some((e) => e.kind === "ngmodule")) for (const p of collectImportedPackages(code, file)) referencedPackages.add(p);
+	} catch {}
+	if (visited) for (const p of referencedPackages) {
+		if (p === packageName || visited.has(p)) continue;
+		visited.add(p);
+		try {
+			entries.push(...scanPackageDts(p, basePath, visited));
+		} catch {}
+	}
+	return entries;
+}
+/**
+* Read package.json exports to build a map from class name to the correct
+* sub-entry import path (e.g. "MatTabNav" → "@angular/material/tabs").
+*
+* For each sub-entry that has a "types" field, the corresponding .d.ts file
+* is read to collect declared class names and re-exported names.
+*/
+function buildClassToImportMap(packageName, pkgDir) {
+	const map = /* @__PURE__ */ new Map();
+	try {
+		const pkgJson = JSON.parse(fs.readFileSync(path$1.join(pkgDir, "package.json"), "utf-8"));
+		if (!pkgJson.exports) return map;
+		for (const [key, value] of Object.entries(pkgJson.exports)) {
+			if (key !== "." && !key.startsWith("./")) continue;
+			let typesFile = typeof value === "object" && value !== null && value.types;
+			if (!typesFile && key === "." && typeof pkgJson.types === "string") typesFile = pkgJson.types;
+			if (!typesFile) continue;
+			const importPath = key === "." ? packageName : packageName + "/" + key.slice(2);
+			const fullTypesPath = path$1.resolve(pkgDir, typesFile);
+			if (!fs.existsSync(fullTypesPath)) continue;
+			collectExportedClassesFromDts(fullTypesPath, importPath, map);
+		}
+	} catch {}
+	return map;
+}
+/**
+* Read a `.d.ts` entry file and add every class it exports to `map`,
+* following `export * from './rel'` chains so re-exported classes from
+* physically nested files (e.g. `lib/foo.d.ts`) are still mapped to the
+* exporting entry's import path.
+*
+* Without this, packages whose root `index.d.ts` is just a barrel of
+* `export * from './lib/...'` would never get their classes mapped, and the
+* `subEntryFromFilePath` fallback would derive an invalid `${pkg}/lib`
+* import for files living under `lib/`.
+*/
+function collectExportedClassesFromDts(filePath, importPath, map, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(filePath)) return;
+	visited.add(filePath);
+	let code;
+	try {
+		code = fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return;
+	}
+	let program;
+	try {
+		program = parseSync(filePath, code).program;
+	} catch {
+		return;
+	}
+	const dir = path$1.dirname(filePath);
+	for (const stmt of program.body || []) {
+		if (stmt.type === "ClassDeclaration" && stmt.id?.name) {
+			map.set(stmt.id.name, importPath);
+			continue;
+		}
+		if (stmt.type === "ExportNamedDeclaration") {
+			if (stmt.declaration?.type === "ClassDeclaration" && stmt.declaration.id?.name) map.set(stmt.declaration.id.name, importPath);
+			for (const spec of stmt.specifiers || []) {
+				const exportedNode = spec.exported;
+				const exportedName = exportedNode?.type === "Identifier" ? exportedNode.name : exportedNode?.type === "Literal" ? exportedNode.value : void 0;
+				if (typeof exportedName === "string") map.set(exportedName, importPath);
+			}
+			continue;
+		}
+		if (stmt.type === "ExportAllDeclaration") {
+			const rel = stmt.source?.value;
+			if (!rel || !rel.startsWith(".")) continue;
+			const normalizedRel = rel.replace(/\.(?:js|mjs)$/u, "");
+			const candidates = [path$1.resolve(dir, normalizedRel + ".d.ts"), path$1.resolve(dir, normalizedRel, "index.d.ts")];
+			for (const candidate of candidates) if (fs.existsSync(candidate)) {
+				collectExportedClassesFromDts(candidate, importPath, map, visited);
+				break;
+			}
+			continue;
+		}
+	}
+}
+/**
+* Derive a sub-entry import path from a .d.ts file's location relative to the
+* package root. This handles older Angular packages that keep .d.ts files in
+* subdirectories (e.g. `@angular/material/tabs/index.d.ts`) instead of a
+* top-level `types/` folder.
+*
+* Returns `undefined` when no sub-entry can be determined (e.g. file is at the
+* package root, inside `types/`, or in a non-entry directory).
+*/
+function subEntryFromFilePath(packageName, pkgDir, filePath) {
+	const NON_ENTRY_DIRS = new Set([
+		"types",
+		"fesm2022",
+		"fesm2020",
+		"fesm2015",
+		"esm2022",
+		"esm2020",
+		"esm2015",
+		"bundles",
+		"schematics",
+		"node_modules"
+	]);
+	const segments = path$1.relative(pkgDir, filePath).split(path$1.sep);
+	if (segments.length < 2) return void 0;
+	const firstDir = segments[0];
+	if (NON_ENTRY_DIRS.has(firstDir) || firstDir.startsWith("_")) return void 0;
+	return packageName + "/" + firstDir;
+}
+/**
+* Parse a source file with OXC and return the set of bare-specifier package
+* names it imports (e.g. "@angular/router", "rxjs"). Relative imports are
+* skipped.
+*/
+function collectImportedPackages(code, fileName, program) {
+	const packages = /* @__PURE__ */ new Set();
+	program ??= parseSync(fileName, code).program;
+	for (const stmt of program.body) {
+		if (stmt.type !== "ImportDeclaration") continue;
+		const specifier = stmt.source?.value;
+		if (!specifier || specifier.startsWith(".")) continue;
+		const parts = specifier.split("/");
+		packages.add(specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0]);
+	}
+	return packages;
+}
+/**
+* Parse a source file with OXC and return the relative-path specifiers it
+* re-exports via `export * from './x'`, `export * as Ns from './x'`, or
+* `export { … } from './x'`. Bare-specifier re-exports are skipped.
+*
+* Used by the analog Vite plugin to walk library entry barrels at startup
+* (e.g. `helm/select/src/index.ts` → `./lib/hlm-select`) so the underlying
+* directive classes land in the registry before any consumer is compiled.
+*/
+function collectRelativeReExports(code, fileName, program) {
+	if (!program) try {
+		program = parseSync(fileName, code).program;
+	} catch {
+		return [];
+	}
+	const result = [];
+	for (const stmt of program.body || []) {
+		if (stmt.type !== "ExportAllDeclaration" && stmt.type !== "ExportNamedDeclaration") continue;
+		const specifier = stmt.source?.value;
+		if (!specifier || !specifier.startsWith(".")) continue;
+		result.push(specifier);
+	}
+	return result;
+}
+/**
+* Parse a source file with OXC and return every module specifier it imports or
+* re-exports from (relative AND bare), including `import`, `export * from`, and
+* `export { … } from`. Used to walk the transitive import graph at startup so
+* the registry contains components/directives/pipes/modules from files not
+* directly listed in tsconfig `files`/`include` (transitively-imported app
+* sources) or behind wildcard `paths` (workspace libraries).
+*/
+function collectAllImports(code, fileName, program) {
+	if (!program) try {
+		program = parseSync(fileName, code).program;
+	} catch {
+		return [];
+	}
+	const result = [];
+	for (const stmt of program.body || []) if (stmt.type === "ImportDeclaration" || stmt.type === "ExportAllDeclaration" || stmt.type === "ExportNamedDeclaration") {
+		const specifier = stmt.source?.value;
+		if (specifier) result.push(specifier);
+	}
+	return result;
+}
+function visitStatements(stmts, fileName, entries) {
+	for (const stmt of stmts) {
+		const decl = stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration" ? stmt.declaration : stmt;
+		if (!decl) continue;
+		if (decl.type === "TSModuleDeclaration" && decl.body?.body) {
+			visitStatements(decl.body.body, fileName, entries);
+			continue;
+		}
+		if (decl.type !== "ClassDeclaration" || !decl.id?.name) continue;
+		const className = decl.id.name;
+		const members = decl.body?.body || [];
+		for (const member of members) {
+			if (member.type !== "PropertyDefinition" || !member.static) continue;
+			const propName = member.key?.name;
+			const typeRef = member.typeAnnotation?.typeAnnotation;
+			if (!typeRef || typeRef.type !== "TSTypeReference") continue;
+			const typeName = qualifiedName(typeRef.typeName);
+			const typeParams = typeRef.typeArguments?.params;
+			if ((propName === "ɵdir" || propName === "ɵcmp") && (typeName.includes("DirectiveDeclaration") || typeName.includes("ComponentDeclaration")) && typeParams && typeParams.length >= 5) {
+				const selector = literalString(typeParams[1]);
+				if (!selector) continue;
+				const inputs = extractInputs(typeParams[3]);
+				const outputs = extractOutputs(typeParams[4]);
+				entries.push({
+					selector: selector.split(",")[0].trim(),
+					kind: propName === "ɵcmp" ? "component" : "directive",
+					fileName,
+					className,
+					...Object.keys(inputs).length > 0 ? { inputs } : {},
+					...Object.keys(outputs).length > 0 ? { outputs } : {}
+				});
+			} else if (propName === "ɵpipe" && typeName.includes("PipeDeclaration") && typeParams && typeParams.length >= 2) {
+				const pipeName = literalString(typeParams[1]);
+				if (!pipeName) continue;
+				entries.push({
+					selector: pipeName,
+					kind: "pipe",
+					pipeName,
+					fileName,
+					className
+				});
+			} else if (propName === "ɵmod" && typeName.includes("NgModuleDeclaration") && typeParams && typeParams.length >= 4) {
+				const exportsParam = typeParams[3];
+				const exportedNames = [];
+				if (exportsParam?.type === "TSTupleType" && exportsParam.elementTypes) {
+					for (const el of exportsParam.elementTypes) if (el.type === "TSTypeQuery" && el.exprName?.type === "Identifier") exportedNames.push(el.exprName.name);
+					else if (el.type === "TSTypeQuery" && el.exprName?.type === "TSQualifiedName") {
+						const right = el.exprName.right;
+						if (right?.type === "Identifier") exportedNames.push(right.name);
+					}
+				}
+				entries.push({
+					selector: className,
+					kind: "ngmodule",
+					exports: exportedNames,
+					fileName,
+					className
+				});
+			}
+		}
+	}
+}
+/**
+* Extract inputs from the type-argument at position [3].
+*
+* Handles two formats:
+*   v16+:    { "prop": { "alias": "binding"; "required": false; "isSignal"?: true } }
+*   pre-v16: { "prop": "binding" }
+*/
+function extractInputs(node) {
+	const inputs = {};
+	if (node?.type !== "TSTypeLiteral") return inputs;
+	for (const member of node.members) {
+		if (member.type !== "TSPropertySignature") continue;
+		const propName = keyName(member.key);
+		const innerType = member.typeAnnotation?.typeAnnotation;
+		if (!propName || !innerType) continue;
+		if (innerType.type === "TSTypeLiteral") {
+			let alias = propName;
+			let required = false;
+			let isSignal = false;
+			for (const inner of innerType.members) {
+				if (inner.type !== "TSPropertySignature") continue;
+				const key = keyName(inner.key);
+				const val = inner.typeAnnotation?.typeAnnotation;
+				if (!key || !val) continue;
+				if (key === "alias") alias = literalString(val) ?? propName;
+				else if (key === "required") required = literalBoolean(val) === true;
+				else if (key === "isSignal") isSignal = literalBoolean(val) === true;
+			}
+			inputs[propName] = {
+				classPropertyName: propName,
+				bindingPropertyName: alias,
+				isSignal,
+				required
+			};
+		} else {
+			const alias = literalString(innerType);
+			if (alias) inputs[propName] = {
+				classPropertyName: propName,
+				bindingPropertyName: alias,
+				isSignal: false,
+				required: false
+			};
+		}
+	}
+	return inputs;
+}
+/**
+* Extract outputs from the type-argument at position [4].
+* Format: { "propName": "eventName" }
+*/
+function extractOutputs(node) {
+	const outputs = {};
+	if (node?.type !== "TSTypeLiteral") return outputs;
+	for (const member of node.members) {
+		if (member.type !== "TSPropertySignature") continue;
+		const propName = keyName(member.key);
+		const val = member.typeAnnotation?.typeAnnotation;
+		if (!propName || !val) continue;
+		const value = literalString(val);
+		if (value) outputs[propName] = value;
+	}
+	return outputs;
+}
+/** Get the string name from a property key (Identifier or Literal). */
+function keyName(key) {
+	if (!key) return void 0;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+}
+/** Build a dotted name from an Identifier or TSQualifiedName. */
+function qualifiedName(node) {
+	if (!node) return "";
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "TSQualifiedName") return qualifiedName(node.left) + "." + qualifiedName(node.right);
+	return "";
+}
+/** Extract a string value from a TSLiteralType node. */
+function literalString(node) {
+	if (node?.type === "TSLiteralType" && node.literal?.type === "Literal" && typeof node.literal.value === "string") return node.literal.value;
+}
+/** Extract a boolean value from a TSLiteralType node. */
+function literalBoolean(node) {
+	if (node?.type === "TSLiteralType" && node.literal?.type === "Literal" && typeof node.literal.value === "boolean") return node.literal.value;
+}
+/** Recursively collect all .d.ts files under a directory. */
+function collectDtsFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const full = path$1.join(dir, entry.name);
+		if (entry.isDirectory() && entry.name !== "node_modules") results.push(...collectDtsFiles(full));
+		else if (entry.isFile() && entry.name.endsWith(".d.ts")) results.push(full);
+	}
+	return results;
+}
+//#endregion
+export { collectAllImports, collectImportedPackages, collectRelativeReExports, scanDtsFile, scanPackageDts };
+
+//# sourceMappingURL=dts-reader.js.map

package/src/lib/compiler/dts-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dts-reader.js","names":[],"sources":["../../../../src/lib/compiler/dts-reader.ts"],"sourcesContent":["import { parseSync } from 'oxc-parser';\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport { RegistryEntry, RegistryInput } from './registry.js';\n\n/**\n * Scan a single .d.ts file and extract Angular directive/component/pipe\n * metadata from the static ɵdir / ɵcmp / ɵpipe type declarations.\n *\n * This mirrors what ngtsc's DtsMetadataReader does: it reads the type\n * parameters of ɵɵDirectiveDeclaration / ɵɵComponentDeclaration /\n * ɵɵPipeDeclaration to discover selectors, inputs, and outputs for\n * pre-compiled Angular packages.\n */\nexport function scanDtsFile(code: string, fileName: string): RegistryEntry[] {\n  // Fast pre-filter — skip files that can't contain Angular declarations\n  if (\n    !code.includes('DirectiveDeclaration') &&\n    !code.includes('ComponentDeclaration') &&\n    !code.includes('PipeDeclaration') &&\n    !code.includes('NgModuleDeclaration')\n  )\n    return [];\n\n  const { program } = parseSync(fileName, code);\n  const entries: RegistryEntry[] = [];\n\n  visitStatements(program.body, fileName, entries);\n  return entries;\n}\n\n/**\n * Resolve a package's directory in node_modules, scan all its .d.ts files,\n * and return RegistryEntry[] for every Angular declaration found.\n *\n * @param packageName  e.g. \"@angular/router\"\n * @param basePath     project root (where node_modules lives)\n */\nexport function scanPackageDts(\n  packageName: string,\n  basePath: string,\n  visited?: Set<string>,\n): RegistryEntry[] {\n  // Walk up from basePath to find the nearest node_modules containing the package.\n  // This handles monorepos where node_modules is at the workspace root,\n  // not in the project subdirectory.\n  let pkgDir = '';\n  let searchBase = basePath;\n  while (searchBase !== path.dirname(searchBase)) {\n    const candidate = path.join(searchBase, 'node_modules', packageName);\n    if (fs.existsSync(candidate)) {\n      pkgDir = candidate;\n      break;\n    }\n    searchBase = path.dirname(searchBase);\n  }\n  if (!pkgDir) return [];\n\n  // Build a map from className → correct import path using package.json exports.\n  // This handles packages with sub-entry points (e.g. @angular/material/tabs)\n  // where re-exported classes must be imported from their origin entry point.\n  const classToImportPath = buildClassToImportMap(packageName, pkgDir);\n\n  // Check for a \"types\" directory first (Angular packages use this),\n  // then fall back to the package root.\n  const typesDir = path.join(pkgDir, 'types');\n  const searchDir = fs.existsSync(typesDir) ? typesDir : pkgDir;\n\n  const dtsFiles = collectDtsFiles(searchDir);\n  const entries: RegistryEntry[] = [];\n  // Packages re-exported by this package's NgModule declarations. A library\n  // NgModule can re-export another package's module (e.g. BrowserModule exports\n  // CommonModule), so those packages must be scanned too or their directives\n  // (NgIf, NgForOf, …) never reach the registry.\n  const referencedPackages = new Set<string>();\n\n  for (const file of dtsFiles) {\n    try {\n      const code = fs.readFileSync(file, 'utf-8');\n      const fileEntries = scanDtsFile(code, file);\n      for (const entry of fileEntries) {\n        entry.sourcePackage =\n          classToImportPath.get(entry.className) ||\n          subEntryFromFilePath(packageName, pkgDir, file) ||\n          packageName;\n      }\n      entries.push(...fileEntries);\n      // Only follow cross-package imports of declaration files that actually\n      // contain an NgModule — those are the ones whose exports can pull in\n      // another package's directives/pipes. This keeps the walk bounded.\n      if (visited && fileEntries.some((e) => e.kind === 'ngmodule')) {\n        for (const p of collectImportedPackages(code, file)) {\n          referencedPackages.add(p);\n        }\n      }\n    } catch {\n      // Skip unreadable files\n    }\n  }\n\n  if (visited) {\n    for (const p of referencedPackages) {\n      if (p === packageName || visited.has(p)) continue;\n      visited.add(p);\n      try {\n        entries.push(...scanPackageDts(p, basePath, visited));\n      } catch {\n        // Package may not have .d.ts or not be Angular\n      }\n    }\n  }\n\n  return entries;\n}\n\n/**\n * Read package.json exports to build a map from class name to the correct\n * sub-entry import path (e.g. \"MatTabNav\" → \"@angular/material/tabs\").\n *\n * For each sub-entry that has a \"types\" field, the corresponding .d.ts file\n * is read to collect declared class names and re-exported names.\n */\nfunction buildClassToImportMap(\n  packageName: string,\n  pkgDir: string,\n): Map<string, string> {\n  const map = new Map<string, string>();\n  try {\n    const pkgJson = JSON.parse(\n      fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf-8'),\n    );\n    if (!pkgJson.exports) return map;\n\n    for (const [key, value] of Object.entries(pkgJson.exports) as [\n      string,\n      any,\n    ][]) {\n      if (key !== '.' && !key.startsWith('./')) continue;\n      // Resolve types from the export entry. Some packages declare\n      // `types` only at the package root (top-level package.json `types`\n      // field) rather than per-export, so fall back to that for `.`.\n      let typesFile: string | undefined =\n        typeof value === 'object' && value !== null && value.types;\n      if (!typesFile && key === '.' && typeof pkgJson.types === 'string') {\n        typesFile = pkgJson.types;\n      }\n      if (!typesFile) continue;\n\n      // Root entry (`.`) maps classes to the bare package name; sub-entries\n      // (`./tabs`) map to `${packageName}/tabs`. Mapping root-exported\n      // classes prevents `subEntryFromFilePath` from deriving an invalid\n      // subpath like `ngx-scrollbar/lib` for files that physically live in\n      // a `lib/` subdirectory but are only re-exported from the root entry.\n      const importPath =\n        key === '.' ? packageName : packageName + '/' + key.slice(2);\n      const fullTypesPath = path.resolve(pkgDir, typesFile);\n      if (!fs.existsSync(fullTypesPath)) continue;\n\n      collectExportedClassesFromDts(fullTypesPath, importPath, map);\n    }\n  } catch {\n    // No package.json or no exports — fall back to packageName\n  }\n  return map;\n}\n\n/**\n * Read a `.d.ts` entry file and add every class it exports to `map`,\n * following `export * from './rel'` chains so re-exported classes from\n * physically nested files (e.g. `lib/foo.d.ts`) are still mapped to the\n * exporting entry's import path.\n *\n * Without this, packages whose root `index.d.ts` is just a barrel of\n * `export * from './lib/...'` would never get their classes mapped, and the\n * `subEntryFromFilePath` fallback would derive an invalid `${pkg}/lib`\n * import for files living under `lib/`.\n */\nfunction collectExportedClassesFromDts(\n  filePath: string,\n  importPath: string,\n  map: Map<string, string>,\n  visited: Set<string> = new Set(),\n): void {\n  if (visited.has(filePath)) return;\n  visited.add(filePath);\n  let code: string;\n  try {\n    code = fs.readFileSync(filePath, 'utf-8');\n  } catch {\n    return;\n  }\n\n  let program: any;\n  try {\n    program = parseSync(filePath, code).program;\n  } catch {\n    return;\n  }\n\n  const dir = path.dirname(filePath);\n  for (const stmt of program.body || []) {\n    // `declare class Foo` (top-level)\n    if (stmt.type === 'ClassDeclaration' && stmt.id?.name) {\n      map.set(stmt.id.name, importPath);\n      continue;\n    }\n\n    // `export declare class Foo` / `export class Foo` /\n    // `export { A, B as C } from '...'` / `export { A, B }`\n    if (stmt.type === 'ExportNamedDeclaration') {\n      if (\n        stmt.declaration?.type === 'ClassDeclaration' &&\n        stmt.declaration.id?.name\n      ) {\n        map.set(stmt.declaration.id.name, importPath);\n      }\n      for (const spec of stmt.specifiers || []) {\n        // ExportSpecifier: { local, exported }\n        const exportedNode = spec.exported;\n        const exportedName =\n          exportedNode?.type === 'Identifier'\n            ? exportedNode.name\n            : exportedNode?.type === 'Literal'\n              ? exportedNode.value\n              : undefined;\n        if (typeof exportedName === 'string') {\n          map.set(exportedName, importPath);\n        }\n      }\n      continue;\n    }\n\n    // `export * from './rel'` and `export * as Ns from './rel'`\n    if (stmt.type === 'ExportAllDeclaration') {\n      const rel: string | undefined = stmt.source?.value;\n      if (!rel || !rel.startsWith('.')) continue;\n      // TypeScript preserves the original specifier text in emitted\n      // `.d.ts` files, so NodeNext-style packages keep their `.js`\n      // (or `.mjs`) extensions in re-exports — but the actual\n      // declaration is at `foo.d.ts` / `foo/index.d.ts`. Strip the\n      // ESM extension before probing.\n      const normalizedRel = rel.replace(/\\.(?:js|mjs)$/u, '');\n      const candidates = [\n        path.resolve(dir, normalizedRel + '.d.ts'),\n        path.resolve(dir, normalizedRel, 'index.d.ts'),\n      ];\n      for (const candidate of candidates) {\n        if (fs.existsSync(candidate)) {\n          collectExportedClassesFromDts(candidate, importPath, map, visited);\n          break;\n        }\n      }\n      continue;\n    }\n  }\n}\n\n/**\n * Derive a sub-entry import path from a .d.ts file's location relative to the\n * package root. This handles older Angular packages that keep .d.ts files in\n * subdirectories (e.g. `@angular/material/tabs/index.d.ts`) instead of a\n * top-level `types/` folder.\n *\n * Returns `undefined` when no sub-entry can be determined (e.g. file is at the\n * package root, inside `types/`, or in a non-entry directory).\n */\nfunction subEntryFromFilePath(\n  packageName: string,\n  pkgDir: string,\n  filePath: string,\n): string | undefined {\n  const NON_ENTRY_DIRS = new Set([\n    'types',\n    'fesm2022',\n    'fesm2020',\n    'fesm2015',\n    'esm2022',\n    'esm2020',\n    'esm2015',\n    'bundles',\n    'schematics',\n    'node_modules',\n  ]);\n  const rel = path.relative(pkgDir, filePath);\n  const segments = rel.split(path.sep);\n  // File directly in pkgDir (no subdirectory) → no sub-entry\n  if (segments.length < 2) return undefined;\n  const firstDir = segments[0];\n  // Skip internal/build directories and chunk files\n  if (NON_ENTRY_DIRS.has(firstDir) || firstDir.startsWith('_'))\n    return undefined;\n  return packageName + '/' + firstDir;\n}\n\n/**\n * Parse a source file with OXC and return the set of bare-specifier package\n * names it imports (e.g. \"@angular/router\", \"rxjs\"). Relative imports are\n * skipped.\n */\nexport function collectImportedPackages(\n  code: string,\n  fileName: string,\n  program?: ReturnType<typeof parseSync>['program'],\n): Set<string> {\n  const packages = new Set<string>();\n  program ??= parseSync(fileName, code).program;\n\n  for (const stmt of program.body) {\n    if (stmt.type !== 'ImportDeclaration') continue;\n    const specifier: string = stmt.source?.value;\n    if (!specifier || specifier.startsWith('.')) continue;\n\n    const parts = specifier.split('/');\n    packages.add(\n      specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0],\n    );\n  }\n\n  return packages;\n}\n\n/**\n * Parse a source file with OXC and return the relative-path specifiers it\n * re-exports via `export * from './x'`, `export * as Ns from './x'`, or\n * `export { … } from './x'`. Bare-specifier re-exports are skipped.\n *\n * Used by the analog Vite plugin to walk library entry barrels at startup\n * (e.g. `helm/select/src/index.ts` → `./lib/hlm-select`) so the underlying\n * directive classes land in the registry before any consumer is compiled.\n */\nexport function collectRelativeReExports(\n  code: string,\n  fileName: string,\n  program?: ReturnType<typeof parseSync>['program'],\n): string[] {\n  if (!program) {\n    try {\n      program = parseSync(fileName, code).program;\n    } catch {\n      return [];\n    }\n  }\n  const result: string[] = [];\n  for (const stmt of program.body || []) {\n    if (\n      stmt.type !== 'ExportAllDeclaration' &&\n      stmt.type !== 'ExportNamedDeclaration'\n    ) {\n      continue;\n    }\n    // ExportNamedDeclaration without `source` is `export { x }` (no\n    // re-export), which we don't care about here.\n    const specifier: string | undefined = stmt.source?.value;\n    if (!specifier || !specifier.startsWith('.')) continue;\n    result.push(specifier);\n  }\n  return result;\n}\n\n/**\n * Parse a source file with OXC and return every module specifier it imports or\n * re-exports from (relative AND bare), including `import`, `export * from`, and\n * `export { … } from`. Used to walk the transitive import graph at startup so\n * the registry contains components/directives/pipes/modules from files not\n * directly listed in tsconfig `files`/`include` (transitively-imported app\n * sources) or behind wildcard `paths` (workspace libraries).\n */\nexport function collectAllImports(\n  code: string,\n  fileName: string,\n  program?: ReturnType<typeof parseSync>['program'],\n): string[] {\n  if (!program) {\n    try {\n      program = parseSync(fileName, code).program;\n    } catch {\n      return [];\n    }\n  }\n  const result: string[] = [];\n  for (const stmt of program.body || []) {\n    if (\n      stmt.type === 'ImportDeclaration' ||\n      stmt.type === 'ExportAllDeclaration' ||\n      stmt.type === 'ExportNamedDeclaration'\n    ) {\n      const specifier: string | undefined = stmt.source?.value;\n      if (specifier) result.push(specifier);\n    }\n  }\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nfunction visitStatements(\n  stmts: any[],\n  fileName: string,\n  entries: RegistryEntry[],\n) {\n  for (const stmt of stmts) {\n    // Unwrap exports: `export declare class ...` / `export default class ...`\n    const decl =\n      stmt.type === 'ExportNamedDeclaration' ||\n      stmt.type === 'ExportDefaultDeclaration'\n        ? stmt.declaration\n        : stmt;\n\n    if (!decl) continue;\n\n    // Recurse into `declare module \"...\" { ... }` blocks\n    if (decl.type === 'TSModuleDeclaration' && decl.body?.body) {\n      visitStatements(decl.body.body, fileName, entries);\n      continue;\n    }\n\n    if (decl.type !== 'ClassDeclaration' || !decl.id?.name) continue;\n    const className: string = decl.id.name;\n    const members: any[] = decl.body?.body || [];\n\n    for (const member of members) {\n      if (member.type !== 'PropertyDefinition' || !member.static) continue;\n      const propName: string | undefined = member.key?.name;\n\n      // Read the type annotation: e.g. `i0.ɵɵDirectiveDeclaration<...>`\n      const typeRef = member.typeAnnotation?.typeAnnotation;\n      if (!typeRef || typeRef.type !== 'TSTypeReference') continue;\n\n      const typeName = qualifiedName(typeRef.typeName);\n      const typeParams: any[] | undefined = typeRef.typeArguments?.params;\n\n      if (\n        (propName === 'ɵdir' || propName === 'ɵcmp') &&\n        (typeName.includes('DirectiveDeclaration') ||\n          typeName.includes('ComponentDeclaration')) &&\n        typeParams &&\n        typeParams.length >= 5\n      ) {\n        const selector = literalString(typeParams[1]);\n        if (!selector) continue;\n\n        const inputs = extractInputs(typeParams[3]);\n        const outputs = extractOutputs(typeParams[4]);\n\n        entries.push({\n          selector: selector.split(',')[0].trim(),\n          kind: propName === 'ɵcmp' ? 'component' : 'directive',\n          fileName,\n          className,\n          ...(Object.keys(inputs).length > 0 ? { inputs } : {}),\n          ...(Object.keys(outputs).length > 0 ? { outputs } : {}),\n        });\n      } else if (\n        propName === 'ɵpipe' &&\n        typeName.includes('PipeDeclaration') &&\n        typeParams &&\n        typeParams.length >= 2\n      ) {\n        const pipeName = literalString(typeParams[1]);\n        if (!pipeName) continue;\n\n        entries.push({\n          selector: pipeName,\n          kind: 'pipe',\n          pipeName,\n          fileName,\n          className,\n        });\n      } else if (\n        propName === 'ɵmod' &&\n        typeName.includes('NgModuleDeclaration') &&\n        typeParams &&\n        typeParams.length >= 4\n      ) {\n        // ɵɵNgModuleDeclaration<Module, Declarations, Imports, Exports>\n        // Extract exported class names from the 4th type param (index 3).\n        const exportsParam = typeParams[3];\n        const exportedNames: string[] = [];\n        if (exportsParam?.type === 'TSTupleType' && exportsParam.elementTypes) {\n          for (const el of exportsParam.elementTypes) {\n            if (\n              el.type === 'TSTypeQuery' &&\n              el.exprName?.type === 'Identifier'\n            ) {\n              exportedNames.push(el.exprName.name);\n            } else if (\n              el.type === 'TSTypeQuery' &&\n              el.exprName?.type === 'TSQualifiedName'\n            ) {\n              // e.g. typeof i2.BidiModule → extract \"BidiModule\"\n              const right = el.exprName.right;\n              if (right?.type === 'Identifier') {\n                exportedNames.push(right.name);\n              }\n            }\n          }\n        }\n        entries.push({\n          selector: className,\n          kind: 'ngmodule',\n          exports: exportedNames,\n          fileName,\n          className,\n        });\n      }\n    }\n  }\n}\n\n/**\n * Extract inputs from the type-argument at position [3].\n *\n * Handles two formats:\n *   v16+:    { \"prop\": { \"alias\": \"binding\"; \"required\": false; \"isSignal\"?: true } }\n *   pre-v16: { \"prop\": \"binding\" }\n */\nfunction extractInputs(node: any): Record<string, RegistryInput> {\n  const inputs: Record<string, RegistryInput> = {};\n  if (node?.type !== 'TSTypeLiteral') return inputs;\n\n  for (const member of node.members) {\n    if (member.type !== 'TSPropertySignature') continue;\n    const propName = keyName(member.key);\n    const innerType = member.typeAnnotation?.typeAnnotation;\n    if (!propName || !innerType) continue;\n\n    if (innerType.type === 'TSTypeLiteral') {\n      // v16+ object format\n      let alias = propName;\n      let required = false;\n      let isSignal = false;\n\n      for (const inner of innerType.members) {\n        if (inner.type !== 'TSPropertySignature') continue;\n        const key = keyName(inner.key);\n        const val = inner.typeAnnotation?.typeAnnotation;\n        if (!key || !val) continue;\n\n        if (key === 'alias') {\n          alias = literalString(val) ?? propName;\n        } else if (key === 'required') {\n          required = literalBoolean(val) === true;\n        } else if (key === 'isSignal') {\n          isSignal = literalBoolean(val) === true;\n        }\n      }\n\n      inputs[propName] = {\n        classPropertyName: propName,\n        bindingPropertyName: alias,\n        isSignal,\n        required,\n      };\n    } else {\n      // pre-v16 string format\n      const alias = literalString(innerType);\n      if (alias) {\n        inputs[propName] = {\n          classPropertyName: propName,\n          bindingPropertyName: alias,\n          isSignal: false,\n          required: false,\n        };\n      }\n    }\n  }\n\n  return inputs;\n}\n\n/**\n * Extract outputs from the type-argument at position [4].\n * Format: { \"propName\": \"eventName\" }\n */\nfunction extractOutputs(node: any): Record<string, string> {\n  const outputs: Record<string, string> = {};\n  if (node?.type !== 'TSTypeLiteral') return outputs;\n\n  for (const member of node.members) {\n    if (member.type !== 'TSPropertySignature') continue;\n    const propName = keyName(member.key);\n    const val = member.typeAnnotation?.typeAnnotation;\n    if (!propName || !val) continue;\n\n    const value = literalString(val);\n    if (value) outputs[propName] = value;\n  }\n\n  return outputs;\n}\n\n/** Get the string name from a property key (Identifier or Literal). */\nfunction keyName(key: any): string | undefined {\n  if (!key) return undefined;\n  if (key.type === 'Identifier') return key.name;\n  if (key.type === 'Literal' && typeof key.value === 'string') return key.value;\n  return undefined;\n}\n\n/** Build a dotted name from an Identifier or TSQualifiedName. */\nfunction qualifiedName(node: any): string {\n  if (!node) return '';\n  if (node.type === 'Identifier') return node.name;\n  if (node.type === 'TSQualifiedName')\n    return qualifiedName(node.left) + '.' + qualifiedName(node.right);\n  return '';\n}\n\n/** Extract a string value from a TSLiteralType node. */\nfunction literalString(node: any): string | undefined {\n  if (\n    node?.type === 'TSLiteralType' &&\n    node.literal?.type === 'Literal' &&\n    typeof node.literal.value === 'string'\n  ) {\n    return node.literal.value;\n  }\n  return undefined;\n}\n\n/** Extract a boolean value from a TSLiteralType node. */\nfunction literalBoolean(node: any): boolean | undefined {\n  if (\n    node?.type === 'TSLiteralType' &&\n    node.literal?.type === 'Literal' &&\n    typeof node.literal.value === 'boolean'\n  ) {\n    return node.literal.value;\n  }\n  return undefined;\n}\n\n/** Recursively collect all .d.ts files under a directory. */\nfunction collectDtsFiles(dir: string): string[] {\n  const results: string[] = [];\n  let entries: fs.Dirent[];\n  try {\n    entries = fs.readdirSync(dir, { withFileTypes: true });\n  } catch {\n    return results;\n  }\n\n  for (const entry of entries) {\n    const full = path.join(dir, entry.name);\n    if (entry.isDirectory() && entry.name !== 'node_modules') {\n      results.push(...collectDtsFiles(full));\n    } else if (entry.isFile() && entry.name.endsWith('.d.ts')) {\n      results.push(full);\n    }\n  }\n\n  return results;\n}\n"],"mappings":"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"}

package/src/lib/compiler/hmr.d.ts

@@ -0,0 +1,16 @@
+import type { RegistryEntry } from "./registry.js";
+/**
+* Generate HMR code using Angular's ɵɵreplaceMetadata for components,
+* and simple field-swap + invalidation for directives/pipes.
+*
+* The applyMetadata callback dynamically copies all ɵ-prefixed static
+* fields (ɵcmp, ɵfac, ɵdir, ɵpipe, etc.) from the newly compiled class
+* to the old class reference that Angular's runtime is tracking.
+*
+* For components, ɵɵreplaceMetadata then merges the old/new definitions
+* and recreates matching LViews in the component tree.
+*
+* For directives and pipes, ɵɵreplaceMetadata does not support them, so
+* we fall back to a full page reload via import.meta.hot.invalidate().
+*/
+export declare function generateHmrCode(declarations: RegistryEntry[], localDepClassNames?: string[]): string;

package/src/lib/compiler/hmr.js

@@ -0,0 +1,69 @@
+//#region packages/vite-plugin-angular/src/lib/compiler/hmr.ts
+/**
+* Generate HMR code using Angular's ɵɵreplaceMetadata for components,
+* and simple field-swap + invalidation for directives/pipes.
+*
+* The applyMetadata callback dynamically copies all ɵ-prefixed static
+* fields (ɵcmp, ɵfac, ɵdir, ɵpipe, etc.) from the newly compiled class
+* to the old class reference that Angular's runtime is tracking.
+*
+* For components, ɵɵreplaceMetadata then merges the old/new definitions
+* and recreates matching LViews in the component tree.
+*
+* For directives and pipes, ɵɵreplaceMetadata does not support them, so
+* we fall back to a full page reload via import.meta.hot.invalidate().
+*/
+function generateHmrCode(declarations, localDepClassNames = []) {
+	const components = declarations.filter((d) => d.kind === "component");
+	const nonComponents = declarations.filter((d) => d.kind !== "component");
+	const applyFns = declarations.map((c) => `
+export function ɵhmr_${c.className}(type) {
+  for (const key of Object.getOwnPropertyNames(${c.className})) {
+    if (key.startsWith('ɵ')) type[key] = ${c.className}[key];
+  }
+}`).join("\n");
+	const localDepsArray = localDepClassNames.length > 0 ? `[${localDepClassNames.join(", ")}]` : "[]";
+	const replaceBlocks = components.map((c) => `
+      try {
+        i0.ɵɵreplaceMetadata(
+          ${c.className},
+          newModule.ɵhmr_${c.className},
+          { i0 },
+          ${localDepsArray},
+          import.meta,
+          "${c.className}"
+        );
+        replaced = true;
+      } catch(e) {
+        // ɵɵreplaceMetadata failed — will fall back to page reload
+      }`).join("\n");
+	const swapBlocks = nonComponents.map((c) => `
+      try {
+        newModule.ɵhmr_${c.className}(${c.className});
+        swapped = true;
+      } catch(e) {}`).join("\n");
+	let acceptBody = `
+    if (!newModule) return;`;
+	if (components.length > 0) acceptBody += `
+    let replaced = false;${replaceBlocks}
+    if (!replaced) {
+      import.meta.hot.invalidate('Component HMR failed, reloading');
+      return;
+    }`;
+	if (nonComponents.length > 0) acceptBody += `
+    let swapped = false;${swapBlocks}
+    if (swapped) {
+      // Directive/pipe definitions updated — full reload needed for Angular
+      // to pick up the new behavior since ɵɵreplaceMetadata only supports components.
+      import.meta.hot.invalidate('Directive/pipe changed, reloading');
+    }`;
+	return `\n${applyFns}
+if (import.meta.hot) {
+  import.meta.hot.accept((newModule) => {${acceptBody}
+  });
+}`;
+}
+//#endregion
+export { generateHmrCode };
+
+//# sourceMappingURL=hmr.js.map

package/src/lib/compiler/hmr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr.js","names":[],"sources":["../../../../src/lib/compiler/hmr.ts"],"sourcesContent":["import type { RegistryEntry } from './registry.js';\n\n/**\n * Generate HMR code using Angular's ɵɵreplaceMetadata for components,\n * and simple field-swap + invalidation for directives/pipes.\n *\n * The applyMetadata callback dynamically copies all ɵ-prefixed static\n * fields (ɵcmp, ɵfac, ɵdir, ɵpipe, etc.) from the newly compiled class\n * to the old class reference that Angular's runtime is tracking.\n *\n * For components, ɵɵreplaceMetadata then merges the old/new definitions\n * and recreates matching LViews in the component tree.\n *\n * For directives and pipes, ɵɵreplaceMetadata does not support them, so\n * we fall back to a full page reload via import.meta.hot.invalidate().\n */\nexport function generateHmrCode(\n  declarations: RegistryEntry[],\n  localDepClassNames: string[] = [],\n): string {\n  const components = declarations.filter((d) => d.kind === 'component');\n  const nonComponents = declarations.filter((d) => d.kind !== 'component');\n\n  // Export applyMetadata functions so the accept callback can access them.\n  // Dynamically copy all ɵ-prefixed static fields to handle ɵcmp, ɵfac,\n  // ɵdir, ɵpipe, ɵmod, ɵinj, ɵprov, and any future Ivy fields.\n  const applyFns = declarations\n    .map(\n      (c) => `\nexport function ɵhmr_${c.className}(type) {\n  for (const key of Object.getOwnPropertyNames(${c.className})) {\n    if (key.startsWith('ɵ')) type[key] = ${c.className}[key];\n  }\n}`,\n    )\n    .join('\\n');\n\n  // Components: use ɵɵreplaceMetadata for full LView recreation\n  const localDepsArray =\n    localDepClassNames.length > 0 ? `[${localDepClassNames.join(', ')}]` : '[]';\n\n  const replaceBlocks = components\n    .map(\n      (c) => `\n      try {\n        i0.ɵɵreplaceMetadata(\n          ${c.className},\n          newModule.ɵhmr_${c.className},\n          { i0 },\n          ${localDepsArray},\n          import.meta,\n          \"${c.className}\"\n        );\n        replaced = true;\n      } catch(e) {\n        // ɵɵreplaceMetadata failed — will fall back to page reload\n      }`,\n    )\n    .join('\\n');\n\n  // Directives/pipes: swap static fields and invalidate\n  const swapBlocks = nonComponents\n    .map(\n      (c) => `\n      try {\n        newModule.ɵhmr_${c.className}(${c.className});\n        swapped = true;\n      } catch(e) {}`,\n    )\n    .join('\\n');\n\n  let acceptBody = `\n    if (!newModule) return;`;\n\n  if (components.length > 0) {\n    acceptBody += `\n    let replaced = false;${replaceBlocks}\n    if (!replaced) {\n      import.meta.hot.invalidate('Component HMR failed, reloading');\n      return;\n    }`;\n  }\n\n  if (nonComponents.length > 0) {\n    acceptBody += `\n    let swapped = false;${swapBlocks}\n    if (swapped) {\n      // Directive/pipe definitions updated — full reload needed for Angular\n      // to pick up the new behavior since ɵɵreplaceMetadata only supports components.\n      import.meta.hot.invalidate('Directive/pipe changed, reloading');\n    }`;\n  }\n\n  return `\\n${applyFns}\nif (import.meta.hot) {\n  import.meta.hot.accept((newModule) => {${acceptBody}\n  });\n}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,SAAgB,gBACd,cACA,qBAA+B,EAAE,EACzB;CACR,MAAM,aAAa,aAAa,QAAQ,MAAM,EAAE,SAAS,YAAY;CACrE,MAAM,gBAAgB,aAAa,QAAQ,MAAM,EAAE,SAAS,YAAY;CAKxE,MAAM,WAAW,aACd,KACE,MAAM;uBACU,EAAE,UAAU;iDACc,EAAE,UAAU;2CAClB,EAAE,UAAU;;GAGlD,CACA,KAAK,KAAK;CAGb,MAAM,iBACJ,mBAAmB,SAAS,IAAI,IAAI,mBAAmB,KAAK,KAAK,CAAC,KAAK;CAEzE,MAAM,gBAAgB,WACnB,KACE,MAAM;;;YAGD,EAAE,UAAU;2BACG,EAAE,UAAU;;YAE3B,eAAe;;aAEd,EAAE,UAAU;;;;;SAMpB,CACA,KAAK,KAAK;CAGb,MAAM,aAAa,cAChB,KACE,MAAM;;yBAEY,EAAE,UAAU,GAAG,EAAE,UAAU;;qBAG/C,CACA,KAAK,KAAK;CAEb,IAAI,aAAa;;AAGjB,KAAI,WAAW,SAAS,EACtB,eAAc;2BACS,cAAc;;;;;AAOvC,KAAI,cAAc,SAAS,EACzB,eAAc;0BACQ,WAAW;;;;;;AAQnC,QAAO,KAAK,SAAS;;2CAEoB,WAAW"}

package/src/lib/compiler/index.d.ts

@@ -0,0 +1,8 @@
+export { compile, type CompileResult, type CompileOptions } from "./compile.js";
+export { ANGULAR_DECORATORS, ANGULAR_DECORATOR_CALL_RE } from "./constants.js";
+export { scanFile, type RegistryEntry, type ComponentRegistry } from "./registry.js";
+export { scanDtsFile, scanPackageDts, collectImportedPackages, collectRelativeReExports, collectAllImports } from "./dts-reader.js";
+export { jitTransform, type JitTransformResult } from "./jit-transform.js";
+export { generateHmrCode } from "./hmr.js";
+export { inlineResourceUrls, extractInlineStyles } from "./resource-inliner.js";
+export { debugCompile, debugRegistry, debugResolve, debugEmit } from "./debug.js";

package/src/lib/compiler/index.js

@@ -0,0 +1,8 @@
+import "./constants.js";
+import "./debug.js";
+import "./compile.js";
+import "./registry.js";
+import "./dts-reader.js";
+import "./jit-transform.js";
+import "./hmr.js";
+import "./resource-inliner.js";

package/src/lib/compiler/jit-metadata.d.ts

@@ -0,0 +1,14 @@
+/**
+* Build ctorParameters for constructor DI in JIT format:
+* [{ type: ServiceA }, { type: ServiceB, decorators: [{type: Optional}] }]
+*
+* Accepts an OXC ClassDeclaration node and the original source string.
+*/
+export declare function buildCtorParameters(classNode: any, sourceCode: string, typeOnlyImports: Set<string>): string | null;
+/**
+* Build propDecorators for field decorators + signal API downleveling.
+* Returns a JS object literal string or null if no props.
+*
+* Accepts an OXC ClassDeclaration node and the original source string.
+*/
+export declare function buildPropDecorators(classNode: any, sourceCode: string): string | null;