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

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/{analog-compiler-plugin.d.ts → fast-compile-plugin.d.ts}

@@ -1,5 +1,5 @@
 import { Plugin } from "vite";
-export interface AnalogCompilerPluginOptions {
+export interface FastCompilePluginOptions {
 	tsconfigGetter: () => string;
 	workspaceRoot: string;
 	inlineStylesExtension: string;
@@ -9,6 +9,6 @@ export interface AnalogCompilerPluginOptions {
 	transformFilter?: (code: string, id: string) => boolean;
 	isTest: boolean;
 	isAstroIntegration: boolean;
-	analogCompilationMode?: "full" | "partial";
+	fastCompileMode?: "full" | "partial";
 }
-export declare function analogCompilerPlugin(pluginOptions: AnalogCompilerPluginOptions): Plugin;
+export declare function fastCompilePlugin(pluginOptions: FastCompilePluginOptions): Plugin;

package/src/lib/{analog-compiler-plugin.js → fast-compile-plugin.js}

@@ -1,21 +1,28 @@
-import { TS_EXT_REGEX, createDepOptimizerConfig, getTsConfigPath } from "./utils/plugin-config.js";
 import { toVirtualRawId, toVirtualStyleId } from "./utils/virtual-ids.js";
-import { loadVirtualRawModule, loadVirtualStyleModule, rewriteHtmlRawImport, rewriteInlineStyleImport } from "./utils/virtual-resources.js";
+import { loadVirtualRawModule, loadVirtualStyleModule, rewriteHtmlRawImport, rewriteInlineStyleImport, shouldPreprocessTestCss } from "./utils/virtual-resources.js";
+import { debugCompile, debugRegistry } from "./compiler/debug.js";
+import { compile } from "./compiler/compile.js";
+import { scanFile } from "./compiler/registry.js";
+import { collectImportedPackages, collectRelativeReExports, scanPackageDts } from "./compiler/dts-reader.js";
+import { jitTransform } from "./compiler/jit-transform.js";
+import { generateHmrCode } from "./compiler/hmr.js";
+import { extractInlineStyles, inlineResourceUrls } from "./compiler/resource-inliner.js";
+import "./compiler/index.js";
+import { TS_EXT_REGEX, createDepOptimizerConfig, getTsConfigPath } from "./utils/plugin-config.js";
 import { promises } from "node:fs";
 import { dirname, resolve } from "node:path";
 import * as compilerCli from "@angular/compiler-cli";
 import * as vite from "vite";
 import { defaultClientConditions, normalizePath, preprocessCSS } from "vite";
-import { collectImportedPackages, collectRelativeReExports, compile, debugCompile, debugRegistry, extractInlineStyles, generateHmrCode, inlineResourceUrls, jitTransform, scanFile, scanPackageDts } from "@analogjs/angular-compiler";
-//#region packages/vite-plugin-angular/src/lib/analog-compiler-plugin.ts
-function analogCompilerPlugin(pluginOptions) {
+//#region packages/vite-plugin-angular/src/lib/fast-compile-plugin.ts
+function fastCompilePlugin(pluginOptions) {
 	let resolvedConfig;
 	let tsConfigResolutionContext = null;
 	let watchMode = false;
-	const analogRegistry = /* @__PURE__ */ new Map();
-	const analogResourceToSource = /* @__PURE__ */ new Map();
+	const registry = /* @__PURE__ */ new Map();
+	const resourceToSource = /* @__PURE__ */ new Map();
 	const scannedDtsPackages = /* @__PURE__ */ new Set();
-	let analogProjectRoot = "";
+	let projectRoot = "";
 	let useDefineForClassFields = true;
 	/**
 	* Scan a file into the registry, then recursively walk its relative
@@ -40,7 +47,7 @@ function analogCompilerPlugin(pluginOptions) {
 			return;
 		}
 		const entries = scanFile(code, file);
-		for (const entry of entries) if (overwrite || !analogRegistry.has(entry.className)) analogRegistry.set(entry.className, entry);
+		for (const entry of entries) if (overwrite || !registry.has(entry.className)) registry.set(entry.className, entry);
 		const dir = dirname(file);
 		for (const rel of collectRelativeReExports(code, file)) {
 			const normalizedRel = rel.replace(/\.(?:js|mjs)$/u, "");
@@ -55,17 +62,17 @@ function analogCompilerPlugin(pluginOptions) {
 			if (!resolved && debugRegistry.enabled) debugRegistry("scanBarrelExports: %s re-export %s did not resolve to %o", file, rel, reExportCandidates);
 		}
 	}
-	async function initAnalogCompiler() {
+	async function initFastCompile() {
 		if (pluginOptions.jit) return;
-		analogRegistry.clear();
+		registry.clear();
 		scannedDtsPackages.clear();
 		const resolvedTsConfigPath = resolveTsConfigPath();
-		analogProjectRoot = dirname(resolvedTsConfigPath);
+		projectRoot = dirname(resolvedTsConfigPath);
 		const config = compilerCli.readConfiguration(resolvedTsConfigPath);
 		useDefineForClassFields = config.options?.useDefineForClassFields ?? true;
 		const candidates = new Set(config.rootNames);
 		const tsPaths = config.options?.paths;
-		const baseUrl = config.options?.baseUrl ?? analogProjectRoot;
+		const baseUrl = config.options?.baseUrl ?? projectRoot;
 		if (tsPaths) for (const targets of Object.values(tsPaths)) for (const target of targets) {
 			if (target.includes("*")) continue;
 			candidates.add(resolve(baseUrl, target));
@@ -74,11 +81,11 @@ function analogCompilerPlugin(pluginOptions) {
 			try {
 				return scanFile(await promises.readFile(file, "utf-8"), file);
 			} catch (e) {
-				if (debugRegistry.enabled) debugRegistry("initAnalogCompiler: skipping unreadable %s: %s", file, e?.message);
+				if (debugRegistry.enabled) debugRegistry("initFastCompile: skipping unreadable %s: %s", file, e?.message);
 				return [];
 			}
 		}));
-		for (const entries of results) for (const entry of entries) analogRegistry.set(entry.className, entry);
+		for (const entries of results) for (const entry of entries) registry.set(entry.className, entry);
 		const buildStartVisited = /* @__PURE__ */ new Set();
 		if (tsPaths) {
 			const barrelCandidates = [];
@@ -88,19 +95,19 @@ function analogCompilerPlugin(pluginOptions) {
 			}
 			await Promise.all(barrelCandidates.map((c) => scanBarrelExports(c, buildStartVisited)));
 		}
-		debugRegistry("initAnalogCompiler done: %d entries from %d candidate files", analogRegistry.size, candidates.size);
+		debugRegistry("initFastCompile done: %d entries from %d candidate files", registry.size, candidates.size);
 	}
 	function ensureDtsRegistryForSource(code, id) {
 		for (const pkg of collectImportedPackages(code, id)) {
 			if (scannedDtsPackages.has(pkg)) continue;
 			scannedDtsPackages.add(pkg);
 			try {
-				const dtsEntries = scanPackageDts(pkg, analogProjectRoot);
-				for (const entry of dtsEntries) if (!analogRegistry.has(entry.className)) analogRegistry.set(entry.className, entry);
+				const dtsEntries = scanPackageDts(pkg, projectRoot);
+				for (const entry of dtsEntries) if (!registry.has(entry.className)) registry.set(entry.className, entry);
 			} catch {}
 		}
 	}
-	async function handleAnalogCompilerTransform(code, id) {
+	async function handleFastCompileTransform(code, id) {
 		if (!/(Component|Directive|Pipe|Injectable|NgModule)\(/.test(code)) return;
 		if (pluginOptions.jit) {
 			const result = jitTransform(code, id);
@@ -118,6 +125,10 @@ function analogCompilerPlugin(pluginOptions) {
 				resolvedInlineStyles = /* @__PURE__ */ new Map();
 				for (let i = 0; i < styleStrings.length; i++) try {
 					const fakePath = id.replace(/\.ts$/, `.inline-${i}.${pluginOptions.inlineStylesExtension}`);
+					if (!shouldPreprocessTestCss(resolvedConfig, fakePath)) {
+						resolvedInlineStyles.set(i, styleStrings[i]);
+						continue;
+					}
 					const processed = await preprocessCSS(styleStrings[i], fakePath, resolvedConfig);
 					resolvedInlineStyles.set(i, processed.code);
 				} catch (e) {
@@ -128,13 +139,13 @@ function analogCompilerPlugin(pluginOptions) {
 		}
 		ensureDtsRegistryForSource(code, id);
 		const result = compile(code, id, {
-			registry: analogRegistry,
+			registry,
 			resolvedStyles,
 			resolvedInlineStyles,
 			useDefineForClassFields,
-			compilationMode: pluginOptions.analogCompilationMode
+			compilationMode: pluginOptions.fastCompileMode
 		});
-		for (const dep of result.resourceDependencies) analogResourceToSource.set(dep, id);
+		for (const dep of result.resourceDependencies) resourceToSource.set(dep, id);
 		let outputCode = (vite.transformWithOxc ? await vite.transformWithOxc(result.code, id, {
 			lang: "ts",
 			sourcemap: false,
@@ -147,7 +158,7 @@ function analogCompilerPlugin(pluginOptions) {
 			sourcemap: false
 		})).code;
 		if (watchMode && pluginOptions.liveReload) {
-			const fileDeclarations = [...analogRegistry.values()].filter((e) => e.fileName === id);
+			const fileDeclarations = [...registry.values()].filter((e) => e.fileName === id);
 			if (fileDeclarations.length > 0) {
 				const localDepClassNames = fileDeclarations.map((e) => e.className);
 				outputCode += generateHmrCode(fileDeclarations, localDepClassNames);
@@ -163,7 +174,7 @@ function analogCompilerPlugin(pluginOptions) {
 		return getTsConfigPath(root, pluginOptions.tsconfigGetter(), isProd, pluginOptions.isTest, isLib);
 	}
 	return {
-		name: "@analogjs/vite-plugin-angular-compiler",
+		name: "@analogjs/vite-plugin-angular-fast-compile",
 		enforce: "pre",
 		async config(config, { command }) {
 			watchMode = command === "serve";
@@ -196,18 +207,18 @@ function analogCompilerPlugin(pluginOptions) {
 			});
 		},
 		async buildStart() {
-			await initAnalogCompiler();
+			await initFastCompile();
 		},
 		async handleHotUpdate(ctx) {
-			if (analogResourceToSource.has(ctx.file)) {
-				const parentSource = analogResourceToSource.get(ctx.file);
+			if (resourceToSource.has(ctx.file)) {
+				const parentSource = resourceToSource.get(ctx.file);
 				const parentModule = ctx.server.moduleGraph.getModuleById(parentSource);
 				if (parentModule) return [parentModule];
 			}
 			if (TS_EXT_REGEX.test(ctx.file)) {
 				const [fileId] = ctx.file.split("?");
-				const oldEntries = [...analogRegistry.entries()].filter(([_, v]) => v.fileName === fileId).map(([k]) => k);
-				for (const key of oldEntries) analogRegistry.delete(key);
+				const oldEntries = [...registry.entries()].filter(([_, v]) => v.fileName === fileId).map(([k]) => k);
+				for (const key of oldEntries) registry.delete(key);
 				await scanBarrelExports(fileId, /* @__PURE__ */ new Set(), true);
 			}
 			return ctx.modules;
@@ -230,7 +241,9 @@ function analogCompilerPlugin(pluginOptions) {
 			if (rawModule !== void 0) return rawModule;
 			if (/\.(css|scss|sass|less)\?inline$/.test(id)) {
 				const filePath = id.split("?")[0];
-				const result = await preprocessCSS(await promises.readFile(filePath, "utf-8"), filePath, resolvedConfig);
+				const code = await promises.readFile(filePath, "utf-8");
+				if (!shouldPreprocessTestCss(resolvedConfig, filePath)) return `export default ${JSON.stringify(code)}`;
+				const result = await preprocessCSS(code, filePath, resolvedConfig);
 				return `export default ${JSON.stringify(result.code)}`;
 			}
 		},
@@ -246,12 +259,12 @@ function analogCompilerPlugin(pluginOptions) {
 			async handler(code, id) {
 				if (pluginOptions.transformFilter && !(pluginOptions.transformFilter(code, id) ?? true)) return;
 				if (id.includes(".ts?")) id = id.replace(/\?(.*)/, "");
-				return handleAnalogCompilerTransform(code, id);
+				return handleFastCompileTransform(code, id);
 			}
 		}
 	};
 }
 //#endregion
-export { analogCompilerPlugin };
+export { fastCompilePlugin };
 
-//# sourceMappingURL=analog-compiler-plugin.js.map
+//# sourceMappingURL=fast-compile-plugin.js.map