@analogjs/vite-plugin-angular 3.0.0-alpha.5 → 3.0.0-alpha.51

package/src/lib/compiler/style-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-ast.js","names":[],"sources":["../../../../src/lib/compiler/style-ast.ts"],"sourcesContent":["import { parseSync } from 'oxc-parser';\n\ntype ProgramNode = ReturnType<typeof parseSync>['program']['body'][number];\n\nfunction getClassDeclaration(node: ProgramNode): any {\n  return node.type === 'ExportNamedDeclaration' ||\n    node.type === 'ExportDefaultDeclaration'\n    ? (node as any).declaration\n    : node;\n}\n\nfunction getPropertyKey(prop: any): string | undefined {\n  return prop.key?.name || prop.key?.value;\n}\n\nfunction getTemplateLiteralText(node: any): string | undefined {\n  if (node?.type !== 'TemplateLiteral' || node.quasis?.length !== 1) {\n    return undefined;\n  }\n\n  return node.quasis[0].value.cooked || node.quasis[0].value.raw;\n}\n\n/**\n * Extract styleUrl/styleUrls values from Angular @Component decorators.\n */\nexport function extractStyleUrls(code: string, fileName: string): string[] {\n  const urls: string[] = [];\n  const { program } = parseSync(fileName, code);\n\n  for (const node of program.body) {\n    const decl = getClassDeclaration(node);\n    if (!decl || decl.type !== 'ClassDeclaration') continue;\n\n    for (const dec of decl.decorators || []) {\n      const expr = dec.expression;\n      if (!expr || expr.type !== 'CallExpression') continue;\n      if (expr.callee?.name !== 'Component') continue;\n\n      const arg = expr.arguments?.[0];\n      if (!arg || arg.type !== 'ObjectExpression') continue;\n\n      for (const prop of arg.properties) {\n        if (prop.type !== 'Property') continue;\n        const key = getPropertyKey(prop);\n        const val = prop.value;\n\n        if (\n          key === 'styleUrl' &&\n          val?.type === 'Literal' &&\n          typeof val.value === 'string'\n        ) {\n          urls.push(val.value);\n        }\n\n        if (key === 'styleUrls' && val?.type === 'ArrayExpression') {\n          for (const el of val.elements) {\n            if (el?.type === 'Literal' && typeof el.value === 'string') {\n              urls.push(el.value);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return urls;\n}\n\n/**\n * Extract inline style strings from Angular @Component decorators.\n */\nexport function extractInlineStyles(code: string, fileName: string): string[] {\n  const styles: string[] = [];\n  const { program } = parseSync(fileName, code);\n\n  for (const node of program.body) {\n    const decl = getClassDeclaration(node);\n    if (!decl || decl.type !== 'ClassDeclaration') continue;\n\n    for (const dec of decl.decorators || []) {\n      const expr = dec.expression;\n      if (!expr || expr.type !== 'CallExpression') continue;\n      if (expr.callee?.name !== 'Component') continue;\n\n      const arg = expr.arguments?.[0];\n      if (!arg || arg.type !== 'ObjectExpression') continue;\n\n      for (const prop of arg.properties) {\n        if (prop.type !== 'Property') continue;\n        const key = getPropertyKey(prop);\n        const val = prop.value;\n\n        if (key !== 'styles') continue;\n\n        if (val?.type === 'ArrayExpression') {\n          for (const el of val.elements) {\n            if (el?.type === 'Literal' && typeof el.value === 'string') {\n              styles.push(el.value);\n              continue;\n            }\n\n            const templateText = getTemplateLiteralText(el);\n            if (templateText !== undefined) {\n              styles.push(templateText);\n            }\n          }\n        } else if (val?.type === 'Literal' && typeof val.value === 'string') {\n          styles.push(val.value);\n        } else {\n          const templateText = getTemplateLiteralText(val);\n          if (templateText !== undefined) {\n            styles.push(templateText);\n          }\n        }\n      }\n    }\n  }\n\n  return styles;\n}\n"],"mappings":";;AAIA,SAAS,oBAAoB,MAAwB;AACnD,QAAO,KAAK,SAAS,4BACnB,KAAK,SAAS,6BACX,KAAa,cACd;;AAGN,SAAS,eAAe,MAA+B;AACrD,QAAO,KAAK,KAAK,QAAQ,KAAK,KAAK;;AAGrC,SAAS,uBAAuB,MAA+B;AAC7D,KAAI,MAAM,SAAS,qBAAqB,KAAK,QAAQ,WAAW,EAC9D;AAGF,QAAO,KAAK,OAAO,GAAG,MAAM,UAAU,KAAK,OAAO,GAAG,MAAM;;;;;AAoD7D,SAAgB,oBAAoB,MAAc,UAA4B;CAC5E,MAAM,SAAmB,EAAE;CAC3B,MAAM,EAAE,YAAY,UAAU,UAAU,KAAK;AAE7C,MAAK,MAAM,QAAQ,QAAQ,MAAM;EAC/B,MAAM,OAAO,oBAAoB,KAAK;AACtC,MAAI,CAAC,QAAQ,KAAK,SAAS,mBAAoB;AAE/C,OAAK,MAAM,OAAO,KAAK,cAAc,EAAE,EAAE;GACvC,MAAM,OAAO,IAAI;AACjB,OAAI,CAAC,QAAQ,KAAK,SAAS,iBAAkB;AAC7C,OAAI,KAAK,QAAQ,SAAS,YAAa;GAEvC,MAAM,MAAM,KAAK,YAAY;AAC7B,OAAI,CAAC,OAAO,IAAI,SAAS,mBAAoB;AAE7C,QAAK,MAAM,QAAQ,IAAI,YAAY;AACjC,QAAI,KAAK,SAAS,WAAY;IAC9B,MAAM,MAAM,eAAe,KAAK;IAChC,MAAM,MAAM,KAAK;AAEjB,QAAI,QAAQ,SAAU;AAEtB,QAAI,KAAK,SAAS,kBAChB,MAAK,MAAM,MAAM,IAAI,UAAU;AAC7B,SAAI,IAAI,SAAS,aAAa,OAAO,GAAG,UAAU,UAAU;AAC1D,aAAO,KAAK,GAAG,MAAM;AACrB;;KAGF,MAAM,eAAe,uBAAuB,GAAG;AAC/C,SAAI,iBAAiB,KAAA,EACnB,QAAO,KAAK,aAAa;;aAGpB,KAAK,SAAS,aAAa,OAAO,IAAI,UAAU,SACzD,QAAO,KAAK,IAAI,MAAM;SACjB;KACL,MAAM,eAAe,uBAAuB,IAAI;AAChD,SAAI,iBAAiB,KAAA,EACnB,QAAO,KAAK,aAAa;;;;;AAOnC,QAAO"}

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

@@ -0,0 +1,13 @@
+import { type ResolvedConfig } from "vite";
+/**
+* Extract styleUrl/styleUrls from source using OXC parser,
+* read and preprocess them via Vite.
+* Returns a Map of absolute path → compiled CSS for the compiler to use.
+*/
+export declare function resolveStyleFiles(code: string, id: string, resolvedConfig: ResolvedConfig): Promise<Map<string, string> | undefined>;
+/**
+* Preprocess inline styles that contain SCSS/Sass syntax.
+* Uses OXC parser to extract style strings from decorator arguments
+* and runs them through Vite's preprocessCSS.
+*/
+export declare function preprocessInlineStyles(code: string, id: string, inlineStyleLanguage: string, resolvedConfig: ResolvedConfig): Promise<Map<number, string> | undefined>;

package/src/lib/compiler/test-helpers.d.ts

@@ -0,0 +1,7 @@
+import { ComponentRegistry } from "./registry";
+export declare function buildRegistry(files: Record<string, string>): ComponentRegistry;
+/** Convenience wrapper: compile and return just the code string. */
+export declare function compileCode(sourceCode: string, fileName: string, registry?: ComponentRegistry): string;
+/** Compile in partial mode and return just the code string. */
+export declare function compilePartialCode(sourceCode: string, fileName: string, registry?: ComponentRegistry): string;
+export declare function expectCompiles(result: string);

package/src/lib/compiler/type-elision.d.ts

@@ -0,0 +1,26 @@
+import MagicString from "magic-string";
+/**
+* Analyse compiled TypeScript source and return the set of imported names
+* that are only referenced in type positions (type annotations, implements
+* clauses, generics, etc.) and can safely be elided.
+*
+* Uses oxc-parser for fast, Rust-based AST analysis — no type-checker needed.
+*/
+export declare function detectTypeOnlyImportNames(code: string): Set<string>;
+/**
+* Elide import specifiers (or entire import declarations) for names that are
+* only used in type positions. Operates on the compiler's TypeScript output
+* (before OXC strips remaining TS syntax).
+*
+* Returns the modified source code, or the original if nothing was elided.
+*/
+export declare function elideTypeOnlyImports(code: string): string;
+/**
+* Elide type-only imports directly on a MagicString instance, so that
+* subsequent `ms.generateMap()` calls produce an accurate sourcemap.
+*
+* Detects type-only names from `ms.toString()` (the fully-mutated code),
+* but reads import positions from `ms.original` (the coordinate system
+* MagicString expects).
+*/
+export declare function elideTypeOnlyImportsMagicString(ms: MagicString): void;

package/src/lib/compiler/type-elision.js

@@ -0,0 +1,211 @@
+import { parseSync } from "oxc-parser";
+import "magic-string";
+//#region packages/vite-plugin-angular/src/lib/compiler/type-elision.ts
+/**
+* AST property keys that represent type-only positions in TypeScript.
+* Identifiers found only under these keys are never emitted as runtime values.
+*/
+var TYPE_POSITION_KEYS = new Set([
+	"typeAnnotation",
+	"typeParameters",
+	"superTypeParameters",
+	"implements",
+	"returnType",
+	"typeArguments"
+]);
+/**
+* AST node types that represent type-level constructs.
+* Any identifier nested inside one of these nodes is in a type position.
+*/
+var TYPE_NODE_TYPES = new Set([
+	"TSTypeAnnotation",
+	"TSTypeReference",
+	"TSTypeParameterInstantiation",
+	"TSTypeParameterDeclaration",
+	"TSInterfaceDeclaration",
+	"TSTypeAliasDeclaration",
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSUnionType",
+	"TSIntersectionType",
+	"TSArrayType",
+	"TSTupleType",
+	"TSFunctionType",
+	"TSConstructorType",
+	"TSMappedType",
+	"TSConditionalType",
+	"TSIndexedAccessType",
+	"TSTypeQuery",
+	"TSTypeLiteral",
+	"TSQualifiedName",
+	"TSInterfaceBody"
+]);
+/**
+* Internal helper: parse code and return both the AST and the set of
+* type-only imported names. Avoids double-parsing when both are needed.
+*/
+function analyzeTypeOnlyImports(code) {
+	const ast = parseSync("file.ts", code).program;
+	const importedNames = /* @__PURE__ */ new Set();
+	for (const node of ast.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.importKind === "type") continue;
+		for (const spec of node.specifiers ?? []) {
+			if (spec.importKind === "type") continue;
+			importedNames.add(spec.local.name);
+		}
+	}
+	if (importedNames.size === 0) return {
+		ast,
+		typeOnlyNames: /* @__PURE__ */ new Set()
+	};
+	const valueReferenced = /* @__PURE__ */ new Set();
+	collectConstructorDiTokens(ast, importedNames, valueReferenced);
+	function walk(node, inTypePosition) {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const item of node) walk(item, inTypePosition);
+			return;
+		}
+		if (valueReferenced.size === importedNames.size) return;
+		if (!inTypePosition && TYPE_NODE_TYPES.has(node.type)) {
+			if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression") {
+				walk(node.expression, false);
+				walk(node.typeAnnotation, true);
+				return;
+			}
+			inTypePosition = true;
+		}
+		if (!inTypePosition && node.type === "ExportNamedDeclaration" && !node.source) {
+			if (node.declaration) walk(node.declaration, false);
+			for (const spec of node.specifiers ?? []) {
+				if (node.exportKind === "type" || spec.exportKind === "type") continue;
+				walk(spec, false);
+			}
+			return;
+		}
+		if (!inTypePosition && node.type === "Identifier" && importedNames.has(node.name)) {
+			valueReferenced.add(node.name);
+			return;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "type" || key === "start" || key === "end" || key === "range" || key === "loc") continue;
+			const isTypePos = inTypePosition || TYPE_POSITION_KEYS.has(key);
+			walk(node[key], isTypePos);
+		}
+	}
+	for (const node of ast.body) if (node.type !== "ImportDeclaration") walk(node, false);
+	const typeOnly = /* @__PURE__ */ new Set();
+	for (const name of importedNames) if (!valueReferenced.has(name)) typeOnly.add(name);
+	return {
+		ast,
+		typeOnlyNames: typeOnly
+	};
+}
+/**
+* Walk the program looking for decorated classes with constructors and add
+* the type names from constructor parameter annotations to `valueReferenced`.
+*
+* Constructor parameter types are TypeScript type positions, but for decorated
+* classes they double as runtime DI tokens — Angular's compiler reads them
+* via `compileFactoryFunction` to wire `ɵɵdirectiveInject(...)` calls. The
+* import of the type therefore must NOT be elided as type-only.
+*/
+function collectConstructorDiTokens(ast, importedNames, valueReferenced) {
+	for (const stmt of ast.body || []) {
+		const classNode = stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration" ? stmt.declaration : stmt;
+		if (!classNode || classNode.type !== "ClassDeclaration" && classNode.type !== "ClassExpression") continue;
+		if (!classNode.decorators?.length) continue;
+		const ctor = (classNode.body?.body || []).find((m) => m.type === "MethodDefinition" && m.kind === "constructor");
+		if (!ctor) continue;
+		const params = ctor.value?.params?.items || ctor.value?.params || [];
+		for (const param of params) {
+			const typeAnn = (param.type === "TSParameterProperty" ? param.parameter : param)?.typeAnnotation?.typeAnnotation ?? param?.typeAnnotation?.typeAnnotation;
+			if (!typeAnn) continue;
+			collectTypeReferenceNames(typeAnn, importedNames, valueReferenced);
+		}
+	}
+}
+/**
+* Recursively extract identifier names from a TS type expression and mark
+* any that match an imported name as value-referenced.
+*/
+function collectTypeReferenceNames(typeNode, importedNames, valueReferenced) {
+	if (!typeNode || typeof typeNode !== "object") return;
+	if (typeNode.type === "TSTypeReference" && typeNode.typeName) {
+		const name = typeNode.typeName.name;
+		if (name && importedNames.has(name)) valueReferenced.add(name);
+		if (typeNode.typeArguments) collectTypeReferenceNames(typeNode.typeArguments, importedNames, valueReferenced);
+	} else if (typeNode.type === "TSUnionType" || typeNode.type === "TSIntersectionType") for (const t of typeNode.types || []) collectTypeReferenceNames(t, importedNames, valueReferenced);
+	else if (Array.isArray(typeNode)) for (const t of typeNode) collectTypeReferenceNames(t, importedNames, valueReferenced);
+	else if (typeNode.params) for (const t of typeNode.params) collectTypeReferenceNames(t, importedNames, valueReferenced);
+}
+/**
+* Analyse compiled TypeScript source and return the set of imported names
+* that are only referenced in type positions (type annotations, implements
+* clauses, generics, etc.) and can safely be elided.
+*
+* Uses oxc-parser for fast, Rust-based AST analysis — no type-checker needed.
+*/
+function detectTypeOnlyImportNames(code) {
+	return analyzeTypeOnlyImports(code).typeOnlyNames;
+}
+/**
+* Apply import elision edits to a MagicString instance using positions from
+* a parsed AST.  Shared logic for both the string-based and MagicString APIs.
+*/
+function applyElisionEdits(ms, ast, src, typeOnlyNames) {
+	let edited = false;
+	for (const node of ast.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.importKind === "type") continue;
+		const allSpecs = node.specifiers ?? [];
+		const defaultSpec = allSpecs.find((s) => s.type === "ImportDefaultSpecifier");
+		const namedSpecs = allSpecs.filter((s) => s.type === "ImportSpecifier" && s.importKind !== "type");
+		const elideDefault = defaultSpec && typeOnlyNames.has(defaultSpec.local.name);
+		const keptNamed = namedSpecs.filter((s) => !typeOnlyNames.has(s.local.name));
+		const removingNamed = namedSpecs.length - keptNamed.length;
+		if (!elideDefault && removingNamed === 0) continue;
+		let declEnd = node.end;
+		while (declEnd < src.length && (src[declEnd] === "\n" || src[declEnd] === "\r")) declEnd++;
+		const keepDefault = defaultSpec && !elideDefault;
+		const hasKeptNamed = keptNamed.length > 0;
+		if (!keepDefault && !hasKeptNamed) {
+			ms.remove(node.start, declEnd);
+			edited = true;
+		} else {
+			const parts = [];
+			if (keepDefault) parts.push(defaultSpec.local.name);
+			if (hasKeptNamed) {
+				const namedList = keptNamed.map((s) => {
+					const imported = s.imported?.name ?? s.local.name;
+					return imported === s.local.name ? s.local.name : `${imported} as ${s.local.name}`;
+				});
+				parts.push(`{ ${namedList.join(", ")} }`);
+			}
+			const source = node.source.value;
+			const quote = src[node.source.start];
+			ms.overwrite(node.start, node.end, `import ${parts.join(", ")} from ${quote}${source}${quote};`);
+			edited = true;
+		}
+	}
+	return edited;
+}
+/**
+* Elide type-only imports directly on a MagicString instance, so that
+* subsequent `ms.generateMap()` calls produce an accurate sourcemap.
+*
+* Detects type-only names from `ms.toString()` (the fully-mutated code),
+* but reads import positions from `ms.original` (the coordinate system
+* MagicString expects).
+*/
+function elideTypeOnlyImportsMagicString(ms) {
+	const typeOnlyNames = detectTypeOnlyImportNames(ms.toString());
+	if (typeOnlyNames.size === 0) return;
+	const ast = parseSync("file.ts", ms.original).program;
+	applyElisionEdits(ms, ast, ms.original, typeOnlyNames);
+}
+//#endregion
+export { detectTypeOnlyImportNames, elideTypeOnlyImportsMagicString };
+
+//# sourceMappingURL=type-elision.js.map

package/src/lib/compiler/type-elision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-elision.js","names":[],"sources":["../../../../src/lib/compiler/type-elision.ts"],"sourcesContent":["import MagicString from 'magic-string';\nimport { parseSync } from 'oxc-parser';\n\n// ── Type-only import elision via OXC AST ────────────────────────────────\n\n/**\n * AST property keys that represent type-only positions in TypeScript.\n * Identifiers found only under these keys are never emitted as runtime values.\n */\nconst TYPE_POSITION_KEYS = new Set([\n  'typeAnnotation',\n  'typeParameters',\n  'superTypeParameters',\n  'implements',\n  'returnType',\n  'typeArguments',\n]);\n\n/**\n * AST node types that represent type-level constructs.\n * Any identifier nested inside one of these nodes is in a type position.\n */\nconst TYPE_NODE_TYPES = new Set([\n  'TSTypeAnnotation',\n  'TSTypeReference',\n  'TSTypeParameterInstantiation',\n  'TSTypeParameterDeclaration',\n  'TSInterfaceDeclaration',\n  'TSTypeAliasDeclaration',\n  'TSAsExpression',\n  'TSSatisfiesExpression',\n  'TSUnionType',\n  'TSIntersectionType',\n  'TSArrayType',\n  'TSTupleType',\n  'TSFunctionType',\n  'TSConstructorType',\n  'TSMappedType',\n  'TSConditionalType',\n  'TSIndexedAccessType',\n  'TSTypeQuery',\n  'TSTypeLiteral',\n  'TSQualifiedName',\n  'TSInterfaceBody',\n]);\n\n/**\n * Internal helper: parse code and return both the AST and the set of\n * type-only imported names. Avoids double-parsing when both are needed.\n */\nfunction analyzeTypeOnlyImports(code: string): {\n  ast: any;\n  typeOnlyNames: Set<string>;\n} {\n  const ast = parseSync('file.ts', code).program;\n\n  // Step 1 – collect all value-imported names (skip `import type` / `{ type X }`)\n  // Namespace imports (`import * as ns`) are intentionally skipped — they are\n  // always value imports in TypeScript and cannot be type-only at the\n  // declaration level.\n  const importedNames = new Set<string>();\n  for (const node of (ast as any).body) {\n    if (node.type !== 'ImportDeclaration') continue;\n    if (node.importKind === 'type') continue; // already type-only\n    for (const spec of node.specifiers ?? []) {\n      if (spec.importKind === 'type') continue; // already type-only\n      importedNames.add(spec.local.name);\n    }\n  }\n  if (importedNames.size === 0) return { ast, typeOnlyNames: new Set() };\n\n  // Step 2 – walk AST and collect names referenced in value positions\n  const valueReferenced = new Set<string>();\n\n  // Pre-pass: constructor parameter types of decorated classes are DI tokens\n  // and must be preserved as runtime values, even though they appear in\n  // type-annotation positions. Without this, `constructor(svc: MyService)`\n  // would erase the `MyService` import and `extractConstructorDeps` would\n  // emit `ɵɵinvalidFactory()`.\n  collectConstructorDiTokens(ast, importedNames, valueReferenced);\n\n  function walk(node: any, inTypePosition: boolean): void {\n    if (!node || typeof node !== 'object') return;\n    if (Array.isArray(node)) {\n      for (const item of node) walk(item, inTypePosition);\n      return;\n    }\n\n    // Short-circuit: if we found every imported name in a value position, stop\n    if (valueReferenced.size === importedNames.size) return;\n\n    // If this node's type itself marks a type construct, everything below is type-only\n    // Exception: TSAsExpression/TSSatisfiesExpression have a value `expression`\n    // child that is NOT in a type position — only the type annotation is.\n    if (!inTypePosition && TYPE_NODE_TYPES.has(node.type)) {\n      if (\n        node.type === 'TSAsExpression' ||\n        node.type === 'TSSatisfiesExpression'\n      ) {\n        // Walk the expression child in value context, type annotation in type context\n        walk(node.expression, false);\n        walk(node.typeAnnotation, true);\n        return;\n      }\n      inTypePosition = true;\n    }\n\n    // Type-only exports: `export type { Foo }` or `export { type Foo }`\n    // Identifiers inside type-only export specifiers are not value references.\n    if (\n      !inTypePosition &&\n      node.type === 'ExportNamedDeclaration' &&\n      !node.source\n    ) {\n      // Walk the declaration (if any) in value context\n      if (node.declaration) walk(node.declaration, false);\n      // Walk each specifier, skipping type-only ones\n      for (const spec of node.specifiers ?? []) {\n        if (node.exportKind === 'type' || spec.exportKind === 'type') continue;\n        walk(spec, false);\n      }\n      return;\n    }\n\n    if (\n      !inTypePosition &&\n      node.type === 'Identifier' &&\n      importedNames.has(node.name)\n    ) {\n      valueReferenced.add(node.name);\n      return;\n    }\n\n    for (const key of Object.keys(node)) {\n      if (\n        key === 'type' ||\n        key === 'start' ||\n        key === 'end' ||\n        key === 'range' ||\n        key === 'loc'\n      )\n        continue;\n      const isTypePos = inTypePosition || TYPE_POSITION_KEYS.has(key);\n      walk(node[key], isTypePos);\n    }\n  }\n\n  for (const node of (ast as any).body) {\n    // Skip import declarations themselves – we already processed them\n    if (node.type !== 'ImportDeclaration') {\n      walk(node, false);\n    }\n  }\n\n  // Step 3 – names that were imported but never value-referenced are type-only\n  const typeOnly = new Set<string>();\n  for (const name of importedNames) {\n    if (!valueReferenced.has(name)) typeOnly.add(name);\n  }\n  return { ast, typeOnlyNames: typeOnly };\n}\n\n/**\n * Walk the program looking for decorated classes with constructors and add\n * the type names from constructor parameter annotations to `valueReferenced`.\n *\n * Constructor parameter types are TypeScript type positions, but for decorated\n * classes they double as runtime DI tokens — Angular's compiler reads them\n * via `compileFactoryFunction` to wire `ɵɵdirectiveInject(...)` calls. The\n * import of the type therefore must NOT be elided as type-only.\n */\nfunction collectConstructorDiTokens(\n  ast: any,\n  importedNames: Set<string>,\n  valueReferenced: Set<string>,\n): void {\n  for (const stmt of (ast as any).body || []) {\n    const classNode =\n      stmt.type === 'ExportNamedDeclaration' ||\n      stmt.type === 'ExportDefaultDeclaration'\n        ? (stmt as any).declaration\n        : stmt;\n    if (\n      !classNode ||\n      (classNode.type !== 'ClassDeclaration' &&\n        classNode.type !== 'ClassExpression')\n    ) {\n      continue;\n    }\n    if (!classNode.decorators?.length) continue;\n\n    const ctor = (classNode.body?.body || []).find(\n      (m: any) => m.type === 'MethodDefinition' && m.kind === 'constructor',\n    );\n    if (!ctor) continue;\n\n    const params: any[] = ctor.value?.params?.items || ctor.value?.params || [];\n    for (const param of params) {\n      const actualParam =\n        param.type === 'TSParameterProperty' ? param.parameter : param;\n      const typeAnn =\n        actualParam?.typeAnnotation?.typeAnnotation ??\n        param?.typeAnnotation?.typeAnnotation;\n      if (!typeAnn) continue;\n      collectTypeReferenceNames(typeAnn, importedNames, valueReferenced);\n    }\n  }\n}\n\n/**\n * Recursively extract identifier names from a TS type expression and mark\n * any that match an imported name as value-referenced.\n */\nfunction collectTypeReferenceNames(\n  typeNode: any,\n  importedNames: Set<string>,\n  valueReferenced: Set<string>,\n): void {\n  if (!typeNode || typeof typeNode !== 'object') return;\n  if (typeNode.type === 'TSTypeReference' && typeNode.typeName) {\n    const name = typeNode.typeName.name;\n    if (name && importedNames.has(name)) {\n      valueReferenced.add(name);\n    }\n    // Walk type arguments too (e.g. Foo<Bar>)\n    if (typeNode.typeArguments) {\n      collectTypeReferenceNames(\n        typeNode.typeArguments,\n        importedNames,\n        valueReferenced,\n      );\n    }\n  } else if (\n    typeNode.type === 'TSUnionType' ||\n    typeNode.type === 'TSIntersectionType'\n  ) {\n    for (const t of typeNode.types || []) {\n      collectTypeReferenceNames(t, importedNames, valueReferenced);\n    }\n  } else if (Array.isArray(typeNode)) {\n    for (const t of typeNode) {\n      collectTypeReferenceNames(t, importedNames, valueReferenced);\n    }\n  } else if (typeNode.params) {\n    // TSTypeParameterInstantiation\n    for (const t of typeNode.params) {\n      collectTypeReferenceNames(t, importedNames, valueReferenced);\n    }\n  }\n}\n\n/**\n * Analyse compiled TypeScript source and return the set of imported names\n * that are only referenced in type positions (type annotations, implements\n * clauses, generics, etc.) and can safely be elided.\n *\n * Uses oxc-parser for fast, Rust-based AST analysis — no type-checker needed.\n */\nexport function detectTypeOnlyImportNames(code: string): Set<string> {\n  return analyzeTypeOnlyImports(code).typeOnlyNames;\n}\n\n/**\n * Apply import elision edits to a MagicString instance using positions from\n * a parsed AST.  Shared logic for both the string-based and MagicString APIs.\n */\nfunction applyElisionEdits(\n  ms: MagicString,\n  ast: any,\n  src: string,\n  typeOnlyNames: Set<string>,\n): boolean {\n  let edited = false;\n\n  for (const node of (ast as any).body) {\n    if (node.type !== 'ImportDeclaration') continue;\n    if (node.importKind === 'type') continue;\n\n    const allSpecs = node.specifiers ?? [];\n\n    // Separate default and named specifiers\n    const defaultSpec = allSpecs.find(\n      (s: any) => s.type === 'ImportDefaultSpecifier',\n    );\n    const namedSpecs = allSpecs.filter(\n      (s: any) => s.type === 'ImportSpecifier' && s.importKind !== 'type',\n    );\n\n    const elideDefault =\n      defaultSpec && typeOnlyNames.has(defaultSpec.local.name);\n    const keptNamed = namedSpecs.filter(\n      (s: any) => !typeOnlyNames.has(s.local.name),\n    );\n    const removingNamed = namedSpecs.length - keptNamed.length;\n\n    // Nothing to elide from this declaration\n    if (!elideDefault && removingNamed === 0) continue;\n\n    // Find the end of the declaration including trailing newline\n    let declEnd = node.end;\n    while (\n      declEnd < src.length &&\n      (src[declEnd] === '\\n' || src[declEnd] === '\\r')\n    )\n      declEnd++;\n\n    const keepDefault = defaultSpec && !elideDefault;\n    const hasKeptNamed = keptNamed.length > 0;\n\n    if (!keepDefault && !hasKeptNamed) {\n      // Remove entire import declaration\n      ms.remove(node.start, declEnd);\n      edited = true;\n    } else {\n      // Rebuild with only the kept specifiers\n      const parts: string[] = [];\n      if (keepDefault) parts.push(defaultSpec.local.name);\n      if (hasKeptNamed) {\n        const namedList = keptNamed.map((s: any) => {\n          const imported = s.imported?.name ?? s.local.name;\n          return imported === s.local.name\n            ? s.local.name\n            : `${imported} as ${s.local.name}`;\n        });\n        parts.push(`{ ${namedList.join(', ')} }`);\n      }\n      const source = node.source.value;\n      const quote = src[node.source.start]; // preserve original quote style\n      ms.overwrite(\n        node.start,\n        node.end,\n        `import ${parts.join(', ')} from ${quote}${source}${quote};`,\n      );\n      edited = true;\n    }\n  }\n\n  return edited;\n}\n\n/**\n * Elide import specifiers (or entire import declarations) for names that are\n * only used in type positions. Operates on the compiler's TypeScript output\n * (before OXC strips remaining TS syntax).\n *\n * Returns the modified source code, or the original if nothing was elided.\n */\nexport function elideTypeOnlyImports(code: string): string {\n  const { ast, typeOnlyNames } = analyzeTypeOnlyImports(code);\n  if (typeOnlyNames.size === 0) return code;\n\n  const ms = new MagicString(code);\n  const edited = applyElisionEdits(ms, ast, code, typeOnlyNames);\n  return edited ? ms.toString() : code;\n}\n\n/**\n * Elide type-only imports directly on a MagicString instance, so that\n * subsequent `ms.generateMap()` calls produce an accurate sourcemap.\n *\n * Detects type-only names from `ms.toString()` (the fully-mutated code),\n * but reads import positions from `ms.original` (the coordinate system\n * MagicString expects).\n */\nexport function elideTypeOnlyImportsMagicString(ms: MagicString): void {\n  const typeOnlyNames = detectTypeOnlyImportNames(ms.toString());\n  if (typeOnlyNames.size === 0) return;\n\n  // Parse the original source to get positions in MagicString's coordinate system\n  const ast = parseSync('file.ts', ms.original).program;\n  applyElisionEdits(ms, ast, ms.original, typeOnlyNames);\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import * as ts from "typescript";
+/** Collect type-only imported names: `import type { X }` and `import { type X }`. */
+export declare function collectTypeOnlyImports(sf: ts.SourceFile): Set<string>;
+/** Recursively find all class declarations in a source file, including nested scopes. */
+export declare function findAllClasses(sf: ts.SourceFile): ts.ClassDeclaration[];
+/** Unwrap forwardRef(() => X) to X. Returns the original node if not a forwardRef call. */
+export declare function unwrapForwardRef(node: ts.Expression): ts.Expression;
+/** Unwrap forwardRef(() => X) to X for OXC AST nodes. Returns the original node if not a forwardRef call. */
+export declare function unwrapForwardRefOxc(node: any): any;
+export { ANGULAR_DECORATORS } from "./constants.js";

package/src/lib/compiler/utils.js

@@ -0,0 +1,35 @@
+import "./constants.js";
+import * as ts from "typescript";
+//#region packages/vite-plugin-angular/src/lib/compiler/utils.ts
+/** Recursively find all class declarations in a source file, including nested scopes. */
+function findAllClasses(sf) {
+	const result = [];
+	function walk(node) {
+		if (ts.isClassDeclaration(node)) result.push(node);
+		ts.forEachChild(node, walk);
+	}
+	walk(sf);
+	return result;
+}
+/** Unwrap forwardRef(() => X) to X for OXC AST nodes. Returns the original node if not a forwardRef call. */
+function unwrapForwardRefOxc(node) {
+	if (node?.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "forwardRef") {
+		const arg = node.arguments?.[0];
+		if (arg?.type === "ArrowFunctionExpression") if (arg.body?.type === "FunctionBody" || arg.body?.type === "BlockStatement") {
+			const stmt = (arg.body.statements || arg.body.body || [])[0];
+			if (stmt?.type === "ReturnStatement" && stmt.argument) return stmt.argument;
+		} else return arg.body;
+		if (arg?.type === "FunctionExpression") {
+			const stmts = arg.body?.statements || arg.body?.body || [];
+			if (stmts.length === 1) {
+				const stmt = stmts[0];
+				if (stmt?.type === "ReturnStatement" && stmt.argument) return stmt.argument;
+			}
+		}
+	}
+	return node;
+}
+//#endregion
+export { findAllClasses, unwrapForwardRefOxc };
+
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../../src/lib/compiler/utils.ts"],"sourcesContent":["import * as ts from 'typescript';\n\n/** Collect type-only imported names: `import type { X }` and `import { type X }`. */\nexport function collectTypeOnlyImports(sf: ts.SourceFile): Set<string> {\n  const result = new Set<string>();\n  for (const stmt of sf.statements) {\n    if (!ts.isImportDeclaration(stmt) || !stmt.importClause) continue;\n    const clause = stmt.importClause;\n    if (clause.isTypeOnly) {\n      if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {\n        for (const el of clause.namedBindings.elements)\n          result.add(el.name.text);\n      }\n      if (clause.name) result.add(clause.name.text);\n    } else if (\n      clause.namedBindings &&\n      ts.isNamedImports(clause.namedBindings)\n    ) {\n      for (const el of clause.namedBindings.elements) {\n        if (el.isTypeOnly) result.add(el.name.text);\n      }\n    }\n  }\n  return result;\n}\n\n/** Recursively find all class declarations in a source file, including nested scopes. */\nexport function findAllClasses(sf: ts.SourceFile): ts.ClassDeclaration[] {\n  const result: ts.ClassDeclaration[] = [];\n  function walk(node: ts.Node) {\n    if (ts.isClassDeclaration(node)) result.push(node);\n    ts.forEachChild(node, walk);\n  }\n  walk(sf);\n  return result;\n}\n\n/** Unwrap forwardRef(() => X) to X. Returns the original node if not a forwardRef call. */\nexport function unwrapForwardRef(node: ts.Expression): ts.Expression {\n  if (\n    ts.isCallExpression(node) &&\n    ts.isIdentifier(node.expression) &&\n    node.expression.text === 'forwardRef'\n  ) {\n    const arg = node.arguments[0];\n    if (arg && ts.isArrowFunction(arg)) {\n      if (ts.isBlock(arg.body)) {\n        const stmt = arg.body.statements[0];\n        if (stmt && ts.isReturnStatement(stmt) && stmt.expression)\n          return stmt.expression;\n      } else {\n        return arg.body;\n      }\n    }\n    if (\n      arg &&\n      ts.isFunctionExpression(arg) &&\n      arg.body.statements.length === 1\n    ) {\n      const stmt = arg.body.statements[0];\n      if (ts.isReturnStatement(stmt) && stmt.expression) return stmt.expression;\n    }\n  }\n  return node;\n}\n\n/** Unwrap forwardRef(() => X) to X for OXC AST nodes. Returns the original node if not a forwardRef call. */\nexport function unwrapForwardRefOxc(node: any): any {\n  if (\n    node?.type === 'CallExpression' &&\n    node.callee?.type === 'Identifier' &&\n    node.callee.name === 'forwardRef'\n  ) {\n    const arg = node.arguments?.[0];\n    if (arg?.type === 'ArrowFunctionExpression') {\n      if (\n        arg.body?.type === 'FunctionBody' ||\n        arg.body?.type === 'BlockStatement'\n      ) {\n        const stmts = arg.body.statements || arg.body.body || [];\n        const stmt = stmts[0];\n        if (stmt?.type === 'ReturnStatement' && stmt.argument)\n          return stmt.argument;\n      } else {\n        // Expression body: forwardRef(() => X)\n        return arg.body;\n      }\n    }\n    if (arg?.type === 'FunctionExpression') {\n      const stmts = arg.body?.statements || arg.body?.body || [];\n      if (stmts.length === 1) {\n        const stmt = stmts[0];\n        if (stmt?.type === 'ReturnStatement' && stmt.argument)\n          return stmt.argument;\n      }\n    }\n  }\n  return node;\n}\n\nexport { ANGULAR_DECORATORS } from './constants.js';\n"],"mappings":";;;;AA2BA,SAAgB,eAAe,IAA0C;CACvE,MAAM,SAAgC,EAAE;CACxC,SAAS,KAAK,MAAe;AAC3B,MAAI,GAAG,mBAAmB,KAAK,CAAE,QAAO,KAAK,KAAK;AAClD,KAAG,aAAa,MAAM,KAAK;;AAE7B,MAAK,GAAG;AACR,QAAO;;;AAiCT,SAAgB,oBAAoB,MAAgB;AAClD,KACE,MAAM,SAAS,oBACf,KAAK,QAAQ,SAAS,gBACtB,KAAK,OAAO,SAAS,cACrB;EACA,MAAM,MAAM,KAAK,YAAY;AAC7B,MAAI,KAAK,SAAS,0BAChB,KACE,IAAI,MAAM,SAAS,kBACnB,IAAI,MAAM,SAAS,kBACnB;GAEA,MAAM,QADQ,IAAI,KAAK,cAAc,IAAI,KAAK,QAAQ,EAAE,EACrC;AACnB,OAAI,MAAM,SAAS,qBAAqB,KAAK,SAC3C,QAAO,KAAK;QAGd,QAAO,IAAI;AAGf,MAAI,KAAK,SAAS,sBAAsB;GACtC,MAAM,QAAQ,IAAI,MAAM,cAAc,IAAI,MAAM,QAAQ,EAAE;AAC1D,OAAI,MAAM,WAAW,GAAG;IACtB,MAAM,OAAO,MAAM;AACnB,QAAI,MAAM,SAAS,qBAAqB,KAAK,SAC3C,QAAO,KAAK;;;;AAIpB,QAAO"}

package/src/lib/compiler-plugin.d.ts

@@ -1,14 +1,14 @@
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-import type { DepOptimizationConfig, Rolldown } from 'vite';
-import { CompilerPluginOptions } from './utils/devkit.js';
-type EsbuildOptions = NonNullable<DepOptimizationConfig['esbuildOptions']>;
-type EsbuildPlugin = NonNullable<EsbuildOptions['plugins']>[number];
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.dev/license
+*/
+import type { DepOptimizationConfig, Rolldown } from "vite";
+import { CompilerPluginOptions } from "./utils/devkit.js";
+type EsbuildOptions = NonNullable<DepOptimizationConfig["esbuildOptions"]>;
+type EsbuildPlugin = NonNullable<EsbuildOptions["plugins"]>[number];
 export declare function createCompilerPlugin(pluginOptions: CompilerPluginOptions, isTest: boolean, closeTransformer: boolean): EsbuildPlugin;
-export declare function createRolldownCompilerPlugin(pluginOptions: CompilerPluginOptions): Rolldown.Plugin;
+export declare function createRolldownCompilerPlugin(pluginOptions: CompilerPluginOptions, closeTransformer: boolean): Rolldown.Plugin;
 export {};

package/src/lib/compiler-plugin.js

@@ -1,47 +1,46 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-import { JavaScriptTransformer, } from './utils/devkit.js';
-export function createCompilerPlugin(pluginOptions, isTest, closeTransformer) {
-    const javascriptTransformer = new JavaScriptTransformer({ ...pluginOptions, jit: true }, 1);
-    return {
-        name: 'analogjs-angular-esbuild-deps-optimizer-plugin',
-        async setup(build) {
-            if (!isTest) {
-                build.onLoad({ filter: /\.[cm]?js$/ }, async (args) => {
-                    const contents = await javascriptTransformer.transformFile(args.path);
-                    return {
-                        contents,
-                        loader: 'js',
-                    };
-                });
-            }
-            if (closeTransformer) {
-                build.onEnd(() => javascriptTransformer.close());
-            }
-        },
-    };
+import { jt } from "./utils/devkit.js";
+//#region packages/vite-plugin-angular/src/lib/compiler-plugin.ts
+function createCompilerPlugin(pluginOptions, isTest, closeTransformer) {
+	const javascriptTransformer = new jt({
+		...pluginOptions,
+		jit: true
+	}, 1);
+	return {
+		name: "analogjs-angular-esbuild-deps-optimizer-plugin",
+		async setup(build) {
+			if (!isTest) build.onLoad({ filter: /\.[cm]?js$/ }, async (args) => {
+				return {
+					contents: await javascriptTransformer.transformFile(args.path),
+					loader: "js"
+				};
+			});
+			if (closeTransformer) build.onEnd(() => javascriptTransformer.close());
+		}
+	};
 }
-export function createRolldownCompilerPlugin(pluginOptions) {
-    const javascriptTransformer = new JavaScriptTransformer({ ...pluginOptions, jit: true }, 1);
-    return {
-        name: 'analogjs-rolldown-deps-optimizer-plugin',
-        load: {
-            filter: {
-                id: /\.[cm]?js$/,
-            },
-            async handler(id) {
-                const contents = await javascriptTransformer.transformFile(id);
-                return {
-                    code: Buffer.from(contents).toString('utf-8'),
-                    loader: 'js',
-                };
-            },
-        },
-    };
+function createRolldownCompilerPlugin(pluginOptions, closeTransformer) {
+	const javascriptTransformer = new jt({
+		...pluginOptions,
+		jit: true
+	}, 1);
+	return {
+		name: "analogjs-rolldown-deps-optimizer-plugin",
+		load: {
+			filter: { id: /\.[cm]?js$/ },
+			async handler(id) {
+				const contents = await javascriptTransformer.transformFile(id);
+				return {
+					code: Buffer.from(contents).toString("utf-8"),
+					loader: "js"
+				};
+			}
+		},
+		buildEnd() {
+			if (closeTransformer) javascriptTransformer.close();
+		}
+	};
 }
+//#endregion
+export { createCompilerPlugin, createRolldownCompilerPlugin };
+
 //# sourceMappingURL=compiler-plugin.js.map

package/src/lib/compiler-plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"compiler-plugin.js","sourceRoot":"","sources":["../../../../../packages/vite-plugin-angular/src/lib/compiler-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAEL,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAK3B,MAAM,UAAU,oBAAoB,CAClC,aAAoC,EACpC,MAAe,EACf,gBAAyB;IAEzB,MAAM,qBAAqB,GAAG,IAAI,qBAAqB,CACrD,EAAE,GAAG,aAAa,EAAE,GAAG,EAAE,IAAI,EAAE,EAC/B,CAAC,CACF,CAAC;IAEF,OAAO;QACL,IAAI,EAAE,gDAAgD;QACtD,KAAK,CAAC,KAAK,CAAC,KAAkB;YAC5B,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;oBACpD,MAAM,QAAQ,GAAG,MAAM,qBAAqB,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAEtE,OAAO;wBACL,QAAQ;wBACR,MAAM,EAAE,IAAI;qBACb,CAAC;gBACJ,CAAC,CAAC,CAAC;YACL,CAAC;YAED,IAAI,gBAAgB,EAAE,CAAC;gBACrB,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,qBAAqB,CAAC,KAAK,EAAE,CAAC,CAAC;YACnD,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,4BAA4B,CAC1C,aAAoC;IAEpC,MAAM,qBAAqB,GAAG,IAAI,qBAAqB,CACrD,EAAE,GAAG,aAAa,EAAE,GAAG,EAAE,IAAI,EAAE,EAC/B,CAAC,CACF,CAAC;IACF,OAAO;QACL,IAAI,EAAE,yCAAyC;QAC/C,IAAI,EAAE;YACJ,MAAM,EAAE;gBACN,EAAE,EAAE,YAAY;aACjB;YACD,KAAK,CAAC,OAAO,CAAC,EAAE;gBACd,MAAM,QAAQ,GAAG,MAAM,qBAAqB,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;gBAE/D,OAAO;oBACL,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAC7C,MAAM,EAAE,IAAI;iBACN,CAAC;YACX,CAAC;SACF;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"compiler-plugin.js","names":[],"sources":["../../../src/lib/compiler-plugin.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport type { DepOptimizationConfig, Rolldown } from 'vite';\nimport type { PluginBuild } from 'esbuild';\n\nimport {\n  CompilerPluginOptions,\n  JavaScriptTransformer,\n} from './utils/devkit.js';\n\ntype EsbuildOptions = NonNullable<DepOptimizationConfig['esbuildOptions']>;\ntype EsbuildPlugin = NonNullable<EsbuildOptions['plugins']>[number];\n\nexport function createCompilerPlugin(\n  pluginOptions: CompilerPluginOptions,\n  isTest: boolean,\n  closeTransformer: boolean,\n): EsbuildPlugin {\n  const javascriptTransformer = new JavaScriptTransformer(\n    { ...pluginOptions, jit: true },\n    1,\n  );\n\n  return {\n    name: 'analogjs-angular-esbuild-deps-optimizer-plugin',\n    async setup(build: PluginBuild) {\n      if (!isTest) {\n        build.onLoad({ filter: /\\.[cm]?js$/ }, async (args) => {\n          const contents = await javascriptTransformer.transformFile(args.path);\n\n          return {\n            contents,\n            loader: 'js',\n          };\n        });\n      }\n\n      if (closeTransformer) {\n        build.onEnd(() => javascriptTransformer.close());\n      }\n    },\n  };\n}\n\nexport function createRolldownCompilerPlugin(\n  pluginOptions: CompilerPluginOptions,\n  closeTransformer: boolean,\n): Rolldown.Plugin {\n  const javascriptTransformer = new JavaScriptTransformer(\n    { ...pluginOptions, jit: true },\n    1,\n  );\n  return {\n    name: 'analogjs-rolldown-deps-optimizer-plugin',\n    load: {\n      filter: {\n        id: /\\.[cm]?js$/,\n      },\n      async handler(id) {\n        const contents = await javascriptTransformer.transformFile(id);\n\n        return {\n          code: Buffer.from(contents).toString('utf-8'),\n          loader: 'js',\n        } as any;\n      },\n    },\n    // Close the JavaScriptTransformer worker pool when Rolldown finishes to\n    // prevent leaked handles. Skipped for Astro, which owns the lifecycle.\n    buildEnd() {\n      if (closeTransformer) {\n        javascriptTransformer.close();\n      }\n    },\n  };\n}\n"],"mappings":";;AAmBA,SAAgB,qBACd,eACA,QACA,kBACe;CACf,MAAM,wBAAwB,IAAI,GAChC;EAAE,GAAG;EAAe,KAAK;EAAM,EAC/B,EACD;AAED,QAAO;EACL,MAAM;EACN,MAAM,MAAM,OAAoB;AAC9B,OAAI,CAAC,OACH,OAAM,OAAO,EAAE,QAAQ,cAAc,EAAE,OAAO,SAAS;AAGrD,WAAO;KACL,UAHe,MAAM,sBAAsB,cAAc,KAAK,KAAK;KAInE,QAAQ;KACT;KACD;AAGJ,OAAI,iBACF,OAAM,YAAY,sBAAsB,OAAO,CAAC;;EAGrD;;AAGH,SAAgB,6BACd,eACA,kBACiB;CACjB,MAAM,wBAAwB,IAAI,GAChC;EAAE,GAAG;EAAe,KAAK;EAAM,EAC/B,EACD;AACD,QAAO;EACL,MAAM;EACN,MAAM;GACJ,QAAQ,EACN,IAAI,cACL;GACD,MAAM,QAAQ,IAAI;IAChB,MAAM,WAAW,MAAM,sBAAsB,cAAc,GAAG;AAE9D,WAAO;KACL,MAAM,OAAO,KAAK,SAAS,CAAC,SAAS,QAAQ;KAC7C,QAAQ;KACT;;GAEJ;EAGD,WAAW;AACT,OAAI,iBACF,uBAAsB,OAAO;;EAGlC"}

package/src/lib/component-resolvers.d.ts

@@ -1,10 +1,28 @@
-export declare class StyleUrlsResolver {
-    private readonly styleUrlsCache;
-    resolve(code: string, id: string): string[];
+export interface AngularComponentMetadata {
+	className: string;
+	selector?: string;
+	styleUrls: string[];
+	templateUrls: string[];
+	inlineTemplates: string[];
 }
+/**
+* Extract Angular component identities from raw source code before Angular's
+* compilation pipeline strips decorators. This is used for dev-time
+* diagnostics such as duplicate selectors, duplicate component class names,
+* selectorless shared components, and inline-template validation.
+*/
+export declare function getAngularComponentMetadata(code: string): AngularComponentMetadata[];
+/** Extract all `styleUrl` / `styleUrls` values from Angular component source. */
 export declare function getStyleUrls(code: string): string[];
+/** Extract all `templateUrl` values from Angular component source. */
 export declare function getTemplateUrls(code: string): string[];
+/** Extract inline `template` strings from Angular component source. */
+export declare function getInlineTemplates(code: string): string[];
+export declare class StyleUrlsResolver {
+	private readonly styleUrlsCache;
+	resolve(code: string, id: string): string[];
+}
 export declare class TemplateUrlsResolver {
-    private readonly templateUrlsCache;
-    resolve(code: string, id: string): string[];
+	private readonly templateUrlsCache;
+	resolve(code: string, id: string): string[];
 }