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

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

@@ -1 +1 @@
-{"version":3,"file":"rolldown.js","names":[],"sources":["../../../../../../packages/vite-plugin-angular/src/lib/utils/rolldown.ts"],"sourcesContent":["import * as vite from 'vite';\n\nexport function isRolldown(): boolean {\n  return !!vite.rolldownVersion;\n}\n\nexport function getJsTransformConfigKey(): 'oxc' | 'esbuild' {\n  return isRolldown() ? 'oxc' : 'esbuild';\n}\n"],"mappings":";;AAEA,SAAgB,aAAsB;AACpC,QAAO,CAAC,CAAC,KAAK;;AAGhB,SAAgB,0BAA6C;AAC3D,QAAO,YAAY,GAAG,QAAQ"}
+{"version":3,"file":"rolldown.js","names":[],"sources":["../../../../src/lib/utils/rolldown.ts"],"sourcesContent":["import * as vite from 'vite';\n\nexport function isRolldown(): boolean {\n  return !!vite.rolldownVersion;\n}\n\nexport function getJsTransformConfigKey(): 'oxc' | 'esbuild' {\n  return isRolldown() ? 'oxc' : 'esbuild';\n}\n"],"mappings":";;AAEA,SAAgB,aAAsB;AACpC,QAAO,CAAC,CAAC,KAAK;;AAGhB,SAAgB,0BAA6C;AAC3D,QAAO,YAAY,GAAG,QAAQ"}

package/src/lib/utils/safe-module-paths.d.ts

@@ -0,0 +1,16 @@
+import { type ResolvedConfig } from "vite";
+/**
+* Mark a style file path as safe in Vite's `safeModulePaths` set so the
+* `?inline` import passes the Denied ID security check without needing
+* the plugin to intercept the load.
+*
+* Vite's own import-analysis transform does the same thing (adds the clean
+* URL to `safeModulePaths` during transform). We additionally add the
+* `?inline` form because `isServerAccessDeniedForTransform` checks *both*
+* `cleanUrl(id)` and the full `id` (with query) against the allow list.
+*
+* This lets `?inline` CSS flow through Vite's native CSS pipeline, which
+* handles preprocessing, `test.css` semantics, and browser-vs-node
+* differences without the plugin having to reimplement any of it.
+*/
+export declare function markStylePathSafe(config: ResolvedConfig | undefined, absPath: string): void;

package/src/lib/utils/safe-module-paths.js

@@ -0,0 +1,29 @@
+import { normalizePath } from "vite";
+//#region packages/vite-plugin-angular/src/lib/utils/safe-module-paths.ts
+/**
+* Mark a style file path as safe in Vite's `safeModulePaths` set so the
+* `?inline` import passes the Denied ID security check without needing
+* the plugin to intercept the load.
+*
+* Vite's own import-analysis transform does the same thing (adds the clean
+* URL to `safeModulePaths` during transform). We additionally add the
+* `?inline` form because `isServerAccessDeniedForTransform` checks *both*
+* `cleanUrl(id)` and the full `id` (with query) against the allow list.
+*
+* This lets `?inline` CSS flow through Vite's native CSS pipeline, which
+* handles preprocessing, `test.css` semantics, and browser-vs-node
+* differences without the plugin having to reimplement any of it.
+*/
+function markStylePathSafe(config, absPath) {
+	if (!config) return;
+	const normalized = normalizePath(absPath);
+	const safeModulePaths = config.safeModulePaths;
+	if (safeModulePaths) {
+		safeModulePaths.add(normalized);
+		safeModulePaths.add(normalized + "?inline");
+	}
+}
+//#endregion
+export { markStylePathSafe };
+
+//# sourceMappingURL=safe-module-paths.js.map

package/src/lib/utils/safe-module-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-module-paths.js","names":[],"sources":["../../../../src/lib/utils/safe-module-paths.ts"],"sourcesContent":["import { normalizePath, type ResolvedConfig } from 'vite';\n\n/**\n * Mark a style file path as safe in Vite's `safeModulePaths` set so the\n * `?inline` import passes the Denied ID security check without needing\n * the plugin to intercept the load.\n *\n * Vite's own import-analysis transform does the same thing (adds the clean\n * URL to `safeModulePaths` during transform). We additionally add the\n * `?inline` form because `isServerAccessDeniedForTransform` checks *both*\n * `cleanUrl(id)` and the full `id` (with query) against the allow list.\n *\n * This lets `?inline` CSS flow through Vite's native CSS pipeline, which\n * handles preprocessing, `test.css` semantics, and browser-vs-node\n * differences without the plugin having to reimplement any of it.\n */\nexport function markStylePathSafe(\n  config: ResolvedConfig | undefined,\n  absPath: string,\n): void {\n  if (!config) return;\n  const normalized = normalizePath(absPath);\n  const safeModulePaths = (config as any).safeModulePaths as\n    | Set<string>\n    | undefined;\n  if (safeModulePaths) {\n    safeModulePaths.add(normalized);\n    safeModulePaths.add(normalized + '?inline');\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,SAAgB,kBACd,QACA,SACM;AACN,KAAI,CAAC,OAAQ;CACb,MAAM,aAAa,cAAc,QAAQ;CACzC,MAAM,kBAAmB,OAAe;AAGxC,KAAI,iBAAiB;AACnB,kBAAgB,IAAI,WAAW;AAC/B,kBAAgB,IAAI,aAAa,UAAU"}

package/src/lib/utils/source-file-cache.d.ts

@@ -1,17 +1,10 @@
-/**
- * @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.io/license
- */
-import type ts from 'typescript';
+import type ts from "typescript";
 export declare class SourceFileCache extends Map<string, ts.SourceFile> {
-    readonly persistentCachePath?: string | undefined;
-    readonly modifiedFiles: Set<string>;
-    readonly babelFileCache: Map<string, Uint8Array>;
-    readonly typeScriptFileCache: Map<string, string | Uint8Array>;
-    referencedFiles?: readonly string[];
-    constructor(persistentCachePath?: string | undefined);
-    invalidate(files: Iterable<string>): void;
+	readonly persistentCachePath?: string | undefined;
+	readonly modifiedFiles: Set<string>;
+	readonly babelFileCache: Map<string, Uint8Array>;
+	readonly typeScriptFileCache: Map<string, string | Uint8Array>;
+	referencedFiles?: readonly string[];
+	constructor(persistentCachePath?: string | undefined);
+	invalidate(files: Iterable<string>): void;
 }

package/src/lib/utils/source-file-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"source-file-cache.js","names":[],"sources":["../../../../../../packages/vite-plugin-angular/src/lib/utils/source-file-cache.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.io/license\n */\n\nimport { platform } from 'node:os';\nimport * as path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type ts from 'typescript';\n\nconst USING_WINDOWS = platform() === 'win32';\nconst WINDOWS_SEP_REGEXP = new RegExp(`\\\\${path.win32.sep}`, 'g');\n\nexport class SourceFileCache extends Map<string, ts.SourceFile> {\n  readonly modifiedFiles: Set<string> = new Set<string>();\n  readonly babelFileCache: Map<string, Uint8Array> = new Map<\n    string,\n    Uint8Array\n  >();\n  readonly typeScriptFileCache: Map<string, string | Uint8Array> = new Map<\n    string,\n    string | Uint8Array\n  >();\n\n  referencedFiles?: readonly string[];\n\n  constructor(readonly persistentCachePath?: string) {\n    super();\n  }\n\n  invalidate(files: Iterable<string>): void {\n    if (files !== this.modifiedFiles) {\n      this.modifiedFiles.clear();\n    }\n    for (let file of files) {\n      this.babelFileCache.delete(file);\n      this.typeScriptFileCache.delete(pathToFileURL(file).href);\n\n      // Normalize separators to allow matching TypeScript Host paths\n      if (USING_WINDOWS) {\n        file = file.replace(WINDOWS_SEP_REGEXP, path.posix.sep);\n      }\n\n      this.delete(file);\n      this.modifiedFiles.add(file);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAaA,IAAM,gBAAgB,UAAU,KAAK;AACrC,IAAM,qBAAqB,IAAI,OAAO,KAAK,OAAK,MAAM,OAAO,IAAI;AAEjE,IAAa,kBAAb,cAAqC,IAA2B;CAC9D,gCAAsC,IAAI,KAAa;CACvD,iCAAmD,IAAI,KAGpD;CACH,sCAAiE,IAAI,KAGlE;CAEH;CAEA,YAAY,qBAAuC;AACjD,SAAO;AADY,OAAA,sBAAA;;CAIrB,WAAW,OAA+B;AACxC,MAAI,UAAU,KAAK,cACjB,MAAK,cAAc,OAAO;AAE5B,OAAK,IAAI,QAAQ,OAAO;AACtB,QAAK,eAAe,OAAO,KAAK;AAChC,QAAK,oBAAoB,OAAO,cAAc,KAAK,CAAC,KAAK;AAGzD,OAAI,cACF,QAAO,KAAK,QAAQ,oBAAoB,OAAK,MAAM,IAAI;AAGzD,QAAK,OAAO,KAAK;AACjB,QAAK,cAAc,IAAI,KAAK"}
+{"version":3,"file":"source-file-cache.js","names":[],"sources":["../../../../src/lib/utils/source-file-cache.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.io/license\n */\n\nimport { platform } from 'node:os';\nimport * as path from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type ts from 'typescript';\n\nconst USING_WINDOWS = platform() === 'win32';\nconst WINDOWS_SEP_REGEXP = new RegExp(`\\\\${path.win32.sep}`, 'g');\n\nexport class SourceFileCache extends Map<string, ts.SourceFile> {\n  readonly modifiedFiles: Set<string> = new Set<string>();\n  readonly babelFileCache: Map<string, Uint8Array> = new Map<\n    string,\n    Uint8Array\n  >();\n  readonly typeScriptFileCache: Map<string, string | Uint8Array> = new Map<\n    string,\n    string | Uint8Array\n  >();\n\n  referencedFiles?: readonly string[];\n\n  constructor(readonly persistentCachePath?: string) {\n    super();\n  }\n\n  invalidate(files: Iterable<string>): void {\n    if (files !== this.modifiedFiles) {\n      this.modifiedFiles.clear();\n    }\n    for (let file of files) {\n      this.babelFileCache.delete(file);\n      this.typeScriptFileCache.delete(pathToFileURL(file).href);\n\n      // Normalize separators to allow matching TypeScript Host paths\n      if (USING_WINDOWS) {\n        file = file.replace(WINDOWS_SEP_REGEXP, path.posix.sep);\n      }\n\n      this.delete(file);\n      this.modifiedFiles.add(file);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAaA,IAAM,gBAAgB,UAAU,KAAK;AACrC,IAAM,qBAAqB,IAAI,OAAO,KAAK,OAAK,MAAM,OAAO,IAAI;AAEjE,IAAa,kBAAb,cAAqC,IAA2B;CAC9D,gCAAsC,IAAI,KAAa;CACvD,iCAAmD,IAAI,KAGpD;CACH,sCAAiE,IAAI,KAGlE;CAEH;CAEA,YAAY,qBAAuC;AACjD,SAAO;AADY,OAAA,sBAAA;;CAIrB,WAAW,OAA+B;AACxC,MAAI,UAAU,KAAK,cACjB,MAAK,cAAc,OAAO;AAE5B,OAAK,IAAI,QAAQ,OAAO;AACtB,QAAK,eAAe,OAAO,KAAK;AAChC,QAAK,oBAAoB,OAAO,cAAc,KAAK,CAAC,KAAK;AAGzD,OAAI,cACF,QAAO,KAAK,QAAQ,oBAAoB,OAAK,MAAM,IAAI;AAGzD,QAAK,OAAO,KAAK;AACjB,QAAK,cAAc,IAAI,KAAK"}

package/src/lib/utils/transform-cache.d.ts

@@ -0,0 +1,43 @@
+/**
+* The `{ get, put }` shape `@angular/build`'s `JavaScriptTransformer`
+* accepts. Keys are content hashes the
+* transformer derives from the file bytes plus every option that affects
+* output, so entries are immutable and never need invalidation — but the
+* digest does NOT cover the linker version, so stores must be namespaced
+* by Angular version (see {@link resolveTransformCacheDir}).
+*/
+export interface TransformCacheStore {
+	get(key: string): Promise<Uint8Array | undefined> | Uint8Array | undefined;
+	put(key: string, value: Uint8Array): Promise<void> | void;
+}
+interface TransformCacheStats {
+	hits: number;
+	misses: number;
+	writes: number;
+	/** Approximate total ms spent in the linker worker for cache misses. */
+	workerMs: number;
+}
+/**
+* Disk-backed content-addressed store for linked/transformed dependency
+* output. Entries are written atomically (temp + rename) so concurrent
+* dev servers can share a directory; all failures degrade to a miss.
+*/
+export declare function createPersistentTransformCache(baseDir: string): TransformCacheStore & {
+	stats: TransformCacheStats;
+};
+/**
+* Layer an unbounded in-memory map over a persistent store so repeat
+* transforms in the same session never touch the disk.
+*/
+export declare function withMemoryLayer(store: TransformCacheStore): TransformCacheStore;
+/**
+* Resolve the shared on-disk cache directory: `node_modules/.cache` at the
+* nearest `node_modules` above `startDir` — the conventional tool-cache
+* location, so installs and `node_modules` cleans evict it without a
+* separate eviction pass. Namespaced by the installed Angular version
+* because the transformer's cache key does not cover the linker version.
+* Returns `null` (caching disabled) when no `node_modules` exists or the
+* `ANALOG_TRANSFORM_CACHE=0` kill switch is set.
+*/
+export declare function resolveTransformCacheDir(startDir: string): string | null;
+export {};

package/src/lib/utils/transform-cache.js

@@ -0,0 +1,97 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path$1 from "node:path";
+import { createDebug } from "obug";
+import { VERSION } from "@angular/compiler";
+//#region packages/vite-plugin-angular/src/lib/utils/transform-cache.ts
+var debugCache = createDebug("analog-transform-cache");
+/**
+* Disk-backed content-addressed store for linked/transformed dependency
+* output. Entries are written atomically (temp + rename) so concurrent
+* dev servers can share a directory; all failures degrade to a miss.
+*/
+function createPersistentTransformCache(baseDir) {
+	const stats = {
+		hits: 0,
+		misses: 0,
+		writes: 0,
+		workerMs: 0
+	};
+	const missedAt = /* @__PURE__ */ new Map();
+	const entryPath = (key) => path$1.join(baseDir, key.slice(0, 2), key);
+	return {
+		stats,
+		async get(key) {
+			try {
+				const value = await fs.promises.readFile(entryPath(key));
+				stats.hits++;
+				debugCache("hit %s (hits=%d misses=%d)", key, stats.hits, stats.misses);
+				return value;
+			} catch {
+				stats.misses++;
+				missedAt.set(key, performance.now());
+				debugCache("miss %s (hits=%d misses=%d)", key, stats.hits, stats.misses);
+				return;
+			}
+		},
+		async put(key, value) {
+			const startedAt = missedAt.get(key);
+			if (startedAt !== void 0) {
+				missedAt.delete(key);
+				stats.workerMs += performance.now() - startedAt;
+			}
+			try {
+				const file = entryPath(key);
+				await fs.promises.mkdir(path$1.dirname(file), { recursive: true });
+				const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}`;
+				await fs.promises.writeFile(tmp, value);
+				await fs.promises.rename(tmp, file);
+				stats.writes++;
+				debugCache("put %s (writes=%d workerMs=%d)", key, stats.writes, Math.round(stats.workerMs));
+			} catch (e) {
+				debugCache("put failed %s: %s", key, e?.message);
+			}
+		}
+	};
+}
+/**
+* Layer an unbounded in-memory map over a persistent store so repeat
+* transforms in the same session never touch the disk.
+*/
+function withMemoryLayer(store) {
+	const memory = /* @__PURE__ */ new Map();
+	return {
+		async get(key) {
+			const cached = memory.get(key) ?? await store.get(key);
+			if (cached) memory.set(key, cached);
+			return cached;
+		},
+		async put(key, value) {
+			memory.set(key, value);
+			await store.put(key, value);
+		}
+	};
+}
+/**
+* Resolve the shared on-disk cache directory: `node_modules/.cache` at the
+* nearest `node_modules` above `startDir` — the conventional tool-cache
+* location, so installs and `node_modules` cleans evict it without a
+* separate eviction pass. Namespaced by the installed Angular version
+* because the transformer's cache key does not cover the linker version.
+* Returns `null` (caching disabled) when no `node_modules` exists or the
+* `ANALOG_TRANSFORM_CACHE=0` kill switch is set.
+*/
+function resolveTransformCacheDir(startDir) {
+	if (process.env["ANALOG_TRANSFORM_CACHE"] === "0") return null;
+	let dir = path$1.resolve(startDir);
+	for (;;) {
+		if (fs.existsSync(path$1.join(dir, "node_modules"))) return path$1.join(dir, "node_modules", ".cache", "analog", "transform-cache", VERSION.full);
+		const parent = path$1.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+//#endregion
+export { createPersistentTransformCache, resolveTransformCacheDir, withMemoryLayer };
+
+//# sourceMappingURL=transform-cache.js.map

package/src/lib/utils/transform-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-cache.js","names":[],"sources":["../../../../src/lib/utils/transform-cache.ts"],"sourcesContent":["import * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport * as crypto from 'node:crypto';\nimport { VERSION } from '@angular/compiler';\nimport { createDebug } from 'obug';\n\nconst debugCache = createDebug('analog-transform-cache');\n\n/**\n * The `{ get, put }` shape `@angular/build`'s `JavaScriptTransformer`\n * accepts. Keys are content hashes the\n * transformer derives from the file bytes plus every option that affects\n * output, so entries are immutable and never need invalidation — but the\n * digest does NOT cover the linker version, so stores must be namespaced\n * by Angular version (see {@link resolveTransformCacheDir}).\n */\nexport interface TransformCacheStore {\n  get(key: string): Promise<Uint8Array | undefined> | Uint8Array | undefined;\n  put(key: string, value: Uint8Array): Promise<void> | void;\n}\n\ninterface TransformCacheStats {\n  hits: number;\n  misses: number;\n  writes: number;\n  /** Approximate total ms spent in the linker worker for cache misses. */\n  workerMs: number;\n}\n\n/**\n * Disk-backed content-addressed store for linked/transformed dependency\n * output. Entries are written atomically (temp + rename) so concurrent\n * dev servers can share a directory; all failures degrade to a miss.\n */\nexport function createPersistentTransformCache(\n  baseDir: string,\n): TransformCacheStore & { stats: TransformCacheStats } {\n  const stats: TransformCacheStats = {\n    hits: 0,\n    misses: 0,\n    writes: 0,\n    workerMs: 0,\n  };\n  // Miss timestamps by key: with the transformer's serialized worker, the\n  // gap between a missed get and its put approximates linker time per file.\n  const missedAt = new Map<string, number>();\n\n  const entryPath = (key: string) => path.join(baseDir, key.slice(0, 2), key);\n\n  return {\n    stats,\n    async get(key: string): Promise<Uint8Array | undefined> {\n      try {\n        const value = await fs.promises.readFile(entryPath(key));\n        stats.hits++;\n        debugCache('hit %s (hits=%d misses=%d)', key, stats.hits, stats.misses);\n        return value;\n      } catch {\n        stats.misses++;\n        missedAt.set(key, performance.now());\n        debugCache(\n          'miss %s (hits=%d misses=%d)',\n          key,\n          stats.hits,\n          stats.misses,\n        );\n        return undefined;\n      }\n    },\n    async put(key: string, value: Uint8Array): Promise<void> {\n      const startedAt = missedAt.get(key);\n      if (startedAt !== undefined) {\n        missedAt.delete(key);\n        stats.workerMs += performance.now() - startedAt;\n      }\n      try {\n        const file = entryPath(key);\n        await fs.promises.mkdir(path.dirname(file), { recursive: true });\n        const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}`;\n        await fs.promises.writeFile(tmp, value);\n        await fs.promises.rename(tmp, file);\n        stats.writes++;\n        debugCache(\n          'put %s (writes=%d workerMs=%d)',\n          key,\n          stats.writes,\n          Math.round(stats.workerMs),\n        );\n      } catch (e) {\n        debugCache('put failed %s: %s', key, (e as Error)?.message);\n      }\n    },\n  };\n}\n\n/**\n * Layer an unbounded in-memory map over a persistent store so repeat\n * transforms in the same session never touch the disk.\n */\nexport function withMemoryLayer(\n  store: TransformCacheStore,\n): TransformCacheStore {\n  const memory = new Map<string, Uint8Array>();\n  return {\n    async get(key: string): Promise<Uint8Array | undefined> {\n      const cached = memory.get(key) ?? (await store.get(key));\n      if (cached) memory.set(key, cached);\n      return cached;\n    },\n    async put(key: string, value: Uint8Array): Promise<void> {\n      memory.set(key, value);\n      await store.put(key, value);\n    },\n  };\n}\n\n/**\n * Resolve the shared on-disk cache directory: `node_modules/.cache` at the\n * nearest `node_modules` above `startDir` — the conventional tool-cache\n * location, so installs and `node_modules` cleans evict it without a\n * separate eviction pass. Namespaced by the installed Angular version\n * because the transformer's cache key does not cover the linker version.\n * Returns `null` (caching disabled) when no `node_modules` exists or the\n * `ANALOG_TRANSFORM_CACHE=0` kill switch is set.\n */\nexport function resolveTransformCacheDir(startDir: string): string | null {\n  if (process.env['ANALOG_TRANSFORM_CACHE'] === '0') return null;\n  let dir = path.resolve(startDir);\n  for (;;) {\n    if (fs.existsSync(path.join(dir, 'node_modules'))) {\n      return path.join(\n        dir,\n        'node_modules',\n        '.cache',\n        'analog',\n        'transform-cache',\n        VERSION.full,\n      );\n    }\n    const parent = path.dirname(dir);\n    if (parent === dir) return null;\n    dir = parent;\n  }\n}\n"],"mappings":";;;;;;AAMA,IAAM,aAAa,YAAY,yBAAyB;;;;;;AA4BxD,SAAgB,+BACd,SACsD;CACtD,MAAM,QAA6B;EACjC,MAAM;EACN,QAAQ;EACR,QAAQ;EACR,UAAU;EACX;CAGD,MAAM,2BAAW,IAAI,KAAqB;CAE1C,MAAM,aAAa,QAAgB,OAAK,KAAK,SAAS,IAAI,MAAM,GAAG,EAAE,EAAE,IAAI;AAE3E,QAAO;EACL;EACA,MAAM,IAAI,KAA8C;AACtD,OAAI;IACF,MAAM,QAAQ,MAAM,GAAG,SAAS,SAAS,UAAU,IAAI,CAAC;AACxD,UAAM;AACN,eAAW,8BAA8B,KAAK,MAAM,MAAM,MAAM,OAAO;AACvE,WAAO;WACD;AACN,UAAM;AACN,aAAS,IAAI,KAAK,YAAY,KAAK,CAAC;AACpC,eACE,+BACA,KACA,MAAM,MACN,MAAM,OACP;AACD;;;EAGJ,MAAM,IAAI,KAAa,OAAkC;GACvD,MAAM,YAAY,SAAS,IAAI,IAAI;AACnC,OAAI,cAAc,KAAA,GAAW;AAC3B,aAAS,OAAO,IAAI;AACpB,UAAM,YAAY,YAAY,KAAK,GAAG;;AAExC,OAAI;IACF,MAAM,OAAO,UAAU,IAAI;AAC3B,UAAM,GAAG,SAAS,MAAM,OAAK,QAAQ,KAAK,EAAE,EAAE,WAAW,MAAM,CAAC;IAChE,MAAM,MAAM,GAAG,KAAK,GAAG,QAAQ,IAAI,GAAG,OAAO,YAAY,EAAE,CAAC,SAAS,MAAM;AAC3E,UAAM,GAAG,SAAS,UAAU,KAAK,MAAM;AACvC,UAAM,GAAG,SAAS,OAAO,KAAK,KAAK;AACnC,UAAM;AACN,eACE,kCACA,KACA,MAAM,QACN,KAAK,MAAM,MAAM,SAAS,CAC3B;YACM,GAAG;AACV,eAAW,qBAAqB,KAAM,GAAa,QAAQ;;;EAGhE;;;;;;AAOH,SAAgB,gBACd,OACqB;CACrB,MAAM,yBAAS,IAAI,KAAyB;AAC5C,QAAO;EACL,MAAM,IAAI,KAA8C;GACtD,MAAM,SAAS,OAAO,IAAI,IAAI,IAAK,MAAM,MAAM,IAAI,IAAI;AACvD,OAAI,OAAQ,QAAO,IAAI,KAAK,OAAO;AACnC,UAAO;;EAET,MAAM,IAAI,KAAa,OAAkC;AACvD,UAAO,IAAI,KAAK,MAAM;AACtB,SAAM,MAAM,IAAI,KAAK,MAAM;;EAE9B;;;;;;;;;;;AAYH,SAAgB,yBAAyB,UAAiC;AACxE,KAAI,QAAQ,IAAI,8BAA8B,IAAK,QAAO;CAC1D,IAAI,MAAM,OAAK,QAAQ,SAAS;AAChC,UAAS;AACP,MAAI,GAAG,WAAW,OAAK,KAAK,KAAK,eAAe,CAAC,CAC/C,QAAO,OAAK,KACV,KACA,gBACA,UACA,UACA,mBACA,QAAQ,KACT;EAEH,MAAM,SAAS,OAAK,QAAQ,IAAI;AAChC,MAAI,WAAW,IAAK,QAAO;AAC3B,QAAM"}

package/src/lib/utils/tsconfig-resolver.d.ts

@@ -0,0 +1,34 @@
+import { ResolvedConfig } from "vite";
+export interface TsconfigResolverOptions {
+	workspaceRoot: string;
+	include: string[];
+	liveReload: boolean;
+	isTest: boolean;
+}
+export declare class TsconfigResolver {
+	private options;
+	private includeCache;
+	private tsconfigOptionsCache;
+	private tsconfigGraphRootCache;
+	private integrationIncludes;
+	constructor(options: TsconfigResolverOptions);
+	/**
+	* Replaces the include globs contributed by Vite plugins through
+	* `analog.setup()`. Invalidates the include cache when the set changes.
+	*/
+	setIntegrationIncludes(globs: string[]): void;
+	private get includeGlobs();
+	invalidateIncludeCache(): void;
+	invalidateTsconfigCaches(): void;
+	invalidateAll(): void;
+	ensureIncludeCache(): string[];
+	readAngularTsconfigConfiguration(resolvedTsConfigPath: string, config: ResolvedConfig);
+	getCachedTsconfigOptions(resolvedTsConfigPath: string, config: ResolvedConfig): {
+		options: any;
+		rootNames: string[];
+	};
+	collectExpandedTsconfigRoots(resolvedTsConfigPath: string, config: ResolvedConfig, visited?): string[];
+	private getTsconfigCacheKey;
+	private findIncludes;
+}
+export declare function normalizeIncludeGlob(workspaceRoot: string, glob: string): string;

package/src/lib/utils/tsconfig-resolver.js

@@ -0,0 +1,205 @@
+import { debugEmit, debugEmitV } from "./debug.js";
+import { existsSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { normalizePath } from "vite";
+import * as compilerCli from "@angular/compiler-cli";
+import { globSync } from "tinyglobby";
+//#region packages/vite-plugin-angular/src/lib/utils/tsconfig-resolver.ts
+/**
+* Shared tsconfig resolution logic used by both the ngtsc and compilation-api
+* compilation plugins. Encapsulates the caching, include-glob discovery,
+* tsconfig-graph expansion, and path-root resolution that were previously
+* duplicated across angular-vite-plugin.ts and compilation-api-plugin.ts.
+*/
+var ts = createRequire(import.meta.url)("typescript");
+var TsconfigResolver = class {
+	includeCache = [];
+	tsconfigOptionsCache = /* @__PURE__ */ new Map();
+	tsconfigGraphRootCache = /* @__PURE__ */ new Map();
+	integrationIncludes = [];
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Replaces the include globs contributed by Vite plugins through
+	* `analog.setup()`. Invalidates the include cache when the set changes.
+	*/
+	setIntegrationIncludes(globs) {
+		if (globs.length === this.integrationIncludes.length && globs.every((glob, index) => glob === this.integrationIncludes[index])) return;
+		this.integrationIncludes = [...globs];
+		this.invalidateIncludeCache();
+	}
+	get includeGlobs() {
+		return [...this.options.include, ...this.integrationIncludes];
+	}
+	invalidateIncludeCache() {
+		this.includeCache = [];
+	}
+	invalidateTsconfigCaches() {
+		this.tsconfigOptionsCache.clear();
+		this.tsconfigGraphRootCache.clear();
+	}
+	invalidateAll() {
+		this.invalidateIncludeCache();
+		this.invalidateTsconfigCaches();
+	}
+	ensureIncludeCache() {
+		if (this.includeGlobs.length > 0 && this.includeCache.length === 0) {
+			this.includeCache = this.findIncludes();
+			debugEmit("include cache populated", { fileCount: this.includeCache.length });
+		}
+		return this.includeCache;
+	}
+	readAngularTsconfigConfiguration(resolvedTsConfigPath, config) {
+		const emitSourceMaps = !(config.mode === "production") || !!config.build?.sourcemap;
+		return compilerCli.readConfiguration(resolvedTsConfigPath, {
+			suppressOutputPathCheck: true,
+			outDir: void 0,
+			sourceMap: emitSourceMaps,
+			inlineSourceMap: false,
+			inlineSources: emitSourceMaps,
+			declaration: false,
+			declarationMap: false,
+			allowEmptyCodegenFiles: false,
+			annotationsAs: "decorators",
+			enableResourceInlining: false,
+			noEmitOnError: false,
+			mapRoot: "",
+			sourceRoot: "",
+			supportTestBed: false,
+			supportJitMode: false
+		});
+	}
+	getCachedTsconfigOptions(resolvedTsConfigPath, config) {
+		const tsconfigKey = this.getTsconfigCacheKey(resolvedTsConfigPath, config);
+		let cached = this.tsconfigOptionsCache.get(tsconfigKey);
+		if (!cached) {
+			const read = this.readAngularTsconfigConfiguration(resolvedTsConfigPath, config);
+			cached = {
+				options: read.options,
+				rootNames: read.rootNames
+			};
+			this.tsconfigOptionsCache.set(tsconfigKey, cached);
+			debugEmit("tsconfig root names loaded", {
+				resolvedTsConfigPath,
+				rootNameCount: read.rootNames.length
+			});
+			debugEmitV("tsconfig root names", {
+				resolvedTsConfigPath,
+				rootNames: read.rootNames.map((file) => normalizePath(file))
+			});
+		}
+		return cached;
+	}
+	collectExpandedTsconfigRoots(resolvedTsConfigPath, config, visited = /* @__PURE__ */ new Set()) {
+		const normalizedTsConfigPath = normalizePath(resolvedTsConfigPath);
+		if (visited.has(normalizedTsConfigPath)) return [];
+		const tsconfigKey = `${this.getTsconfigCacheKey(normalizedTsConfigPath, config)}|graph`;
+		const cached = this.tsconfigGraphRootCache.get(tsconfigKey);
+		if (cached) return cached;
+		visited.add(normalizedTsConfigPath);
+		const read = this.readAngularTsconfigConfiguration(normalizedTsConfigPath, config);
+		const rawTsconfig = ts.readConfigFile(normalizedTsConfigPath, ts.sys.readFile).config ?? {};
+		const expandedRoots = new Set(read.rootNames.map((file) => normalizePath(file)));
+		const pathRoots = collectTsconfigPathRoots(normalizedTsConfigPath, read.options, rawTsconfig);
+		for (const pathRoot of pathRoots) expandedRoots.add(pathRoot);
+		const referenceConfigs = (rawTsconfig.references ?? []).flatMap((reference) => typeof reference.path === "string" ? [resolveReferenceTsconfigPath(reference.path, normalizedTsConfigPath)] : []).filter((reference) => !!reference);
+		for (const referenceConfig of referenceConfigs) for (const referenceRoot of this.collectExpandedTsconfigRoots(referenceConfig, config, visited)) expandedRoots.add(referenceRoot);
+		const expandedRootList = [...expandedRoots];
+		this.tsconfigGraphRootCache.set(tsconfigKey, expandedRootList);
+		debugEmit("expanded tsconfig graph roots", {
+			resolvedTsConfigPath: normalizedTsConfigPath,
+			directRootNameCount: read.rootNames.length,
+			pathRootCount: pathRoots.length,
+			referenceConfigCount: referenceConfigs.length,
+			expandedRootCount: expandedRootList.length
+		});
+		debugEmitV("expanded tsconfig graph root files", {
+			resolvedTsConfigPath: normalizedTsConfigPath,
+			pathRoots,
+			referenceConfigs,
+			rootNames: expandedRootList
+		});
+		return expandedRootList;
+	}
+	getTsconfigCacheKey(resolvedTsConfigPath, config) {
+		const isProd = config.mode === "production";
+		return [
+			resolvedTsConfigPath,
+			isProd ? "prod" : "dev",
+			this.options.isTest ? "test" : "app",
+			config.build?.lib ? "lib" : "nolib",
+			!isProd || config.build?.sourcemap ? "maps" : "nomaps",
+			this.options.liveReload ? "live-reload" : "no-live-reload"
+		].join("|");
+	}
+	findIncludes() {
+		const globs = this.includeGlobs.map((glob) => normalizeIncludeGlob(this.options.workspaceRoot, glob));
+		const files = globSync(globs, {
+			dot: true,
+			absolute: true
+		});
+		debugEmit("include discovery", {
+			patternCount: globs.length,
+			fileCount: files.length
+		});
+		debugEmitV("include discovery files", {
+			globs,
+			files: files.map((file) => normalizePath(file))
+		});
+		return files;
+	}
+};
+function normalizeIncludeGlob(workspaceRoot, glob) {
+	const normalizedWorkspaceRoot = normalizePath(resolve(workspaceRoot));
+	const normalizedGlob = normalizePath(glob);
+	if (normalizedGlob === normalizedWorkspaceRoot || normalizedGlob.startsWith(`${normalizedWorkspaceRoot}/`)) return normalizedGlob;
+	if (normalizedGlob.startsWith("/")) return `${normalizedWorkspaceRoot}${normalizedGlob}`;
+	return normalizePath(resolve(normalizedWorkspaceRoot, normalizedGlob));
+}
+function resolveReferenceTsconfigPath(referencePath, ownerTsconfigPath) {
+	const ownerDir = dirname(ownerTsconfigPath);
+	const resolvedReference = normalizePath(isAbsolute(referencePath) ? referencePath : resolve(ownerDir, referencePath));
+	if (existsSync(resolvedReference)) {
+		try {
+			if (statSync(resolvedReference).isDirectory()) {
+				const nestedTsconfig = join(resolvedReference, "tsconfig.json");
+				return existsSync(nestedTsconfig) ? normalizePath(nestedTsconfig) : void 0;
+			}
+		} catch {
+			return;
+		}
+		return resolvedReference;
+	}
+	if (!resolvedReference.endsWith(".json")) {
+		const asJson = `${resolvedReference}.json`;
+		if (existsSync(asJson)) return normalizePath(asJson);
+		const nestedTsconfig = join(resolvedReference, "tsconfig.json");
+		if (existsSync(nestedTsconfig)) return normalizePath(nestedTsconfig);
+	}
+}
+function collectTsconfigPathRoots(resolvedTsConfigPath, options, rawTsconfig) {
+	const tsPaths = rawTsconfig.compilerOptions?.paths ?? options.paths;
+	if (!tsPaths) return [];
+	const tsconfigDir = dirname(resolvedTsConfigPath);
+	const configuredBaseUrl = typeof options.baseUrl === "string" ? options.baseUrl : typeof rawTsconfig.compilerOptions?.baseUrl === "string" ? rawTsconfig.compilerOptions.baseUrl : void 0;
+	const resolvedBaseUrl = configuredBaseUrl ? isAbsolute(configuredBaseUrl) ? configuredBaseUrl : resolve(tsconfigDir, configuredBaseUrl) : tsconfigDir;
+	const discoveredRoots = /* @__PURE__ */ new Set();
+	for (const targets of Object.values(tsPaths)) for (const target of targets) {
+		const resolvedTarget = normalizePath(isAbsolute(target) ? target : resolve(resolvedBaseUrl, target));
+		if (target.includes("*")) {
+			for (const match of globSync(resolvedTarget, {
+				dot: true,
+				absolute: true
+			})) discoveredRoots.add(normalizePath(match));
+			continue;
+		}
+		if (existsSync(resolvedTarget)) discoveredRoots.add(resolvedTarget);
+	}
+	return [...discoveredRoots];
+}
+//#endregion
+export { TsconfigResolver };
+
+//# sourceMappingURL=tsconfig-resolver.js.map

package/src/lib/utils/tsconfig-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig-resolver.js","names":[],"sources":["../../../../src/lib/utils/tsconfig-resolver.ts"],"sourcesContent":["/**\n * Shared tsconfig resolution logic used by both the ngtsc and compilation-api\n * compilation plugins. Encapsulates the caching, include-glob discovery,\n * tsconfig-graph expansion, and path-root resolution that were previously\n * duplicated across angular-vite-plugin.ts and compilation-api-plugin.ts.\n */\n\nimport * as compilerCli from '@angular/compiler-cli';\nimport { existsSync, statSync } from 'node:fs';\nimport { dirname, isAbsolute, join, resolve } from 'node:path';\nimport { createRequire } from 'node:module';\nimport { normalizePath, ResolvedConfig } from 'vite';\nimport { globSync } from 'tinyglobby';\nimport { debugEmit, debugEmitV } from './debug.js';\n\nconst require = createRequire(import.meta.url);\nconst ts = require('typescript');\n\nexport interface TsconfigResolverOptions {\n  workspaceRoot: string;\n  include: string[];\n  liveReload: boolean;\n  isTest: boolean;\n}\n\nexport class TsconfigResolver {\n  private includeCache: string[] = [];\n  private tsconfigOptionsCache = new Map<\n    string,\n    { options: any; rootNames: string[] }\n  >();\n  private tsconfigGraphRootCache = new Map<string, string[]>();\n  private integrationIncludes: string[] = [];\n\n  constructor(private options: TsconfigResolverOptions) {}\n\n  /**\n   * Replaces the include globs contributed by Vite plugins through\n   * `analog.setup()`. Invalidates the include cache when the set changes.\n   */\n  setIntegrationIncludes(globs: string[]): void {\n    if (\n      globs.length === this.integrationIncludes.length &&\n      globs.every((glob, index) => glob === this.integrationIncludes[index])\n    ) {\n      return;\n    }\n    this.integrationIncludes = [...globs];\n    this.invalidateIncludeCache();\n  }\n\n  private get includeGlobs(): string[] {\n    return [...this.options.include, ...this.integrationIncludes];\n  }\n\n  invalidateIncludeCache(): void {\n    this.includeCache = [];\n  }\n\n  invalidateTsconfigCaches(): void {\n    this.tsconfigOptionsCache.clear();\n    this.tsconfigGraphRootCache.clear();\n  }\n\n  invalidateAll(): void {\n    this.invalidateIncludeCache();\n    this.invalidateTsconfigCaches();\n  }\n\n  ensureIncludeCache(): string[] {\n    if (this.includeGlobs.length > 0 && this.includeCache.length === 0) {\n      this.includeCache = this.findIncludes();\n      debugEmit('include cache populated', {\n        fileCount: this.includeCache.length,\n      });\n    }\n    return this.includeCache;\n  }\n\n  readAngularTsconfigConfiguration(\n    resolvedTsConfigPath: string,\n    config: ResolvedConfig,\n  ) {\n    const isProd = config.mode === 'production';\n    const emitSourceMaps = !isProd || !!config.build?.sourcemap;\n    return compilerCli.readConfiguration(resolvedTsConfigPath, {\n      suppressOutputPathCheck: true,\n      outDir: undefined,\n      sourceMap: emitSourceMaps,\n      inlineSourceMap: false,\n      inlineSources: emitSourceMaps,\n      declaration: false,\n      declarationMap: false,\n      allowEmptyCodegenFiles: false,\n      annotationsAs: 'decorators',\n      enableResourceInlining: false,\n      noEmitOnError: false,\n      mapRoot: '',\n      sourceRoot: '',\n      supportTestBed: false,\n      supportJitMode: false,\n    });\n  }\n\n  getCachedTsconfigOptions(\n    resolvedTsConfigPath: string,\n    config: ResolvedConfig,\n  ): { options: any; rootNames: string[] } {\n    const tsconfigKey = this.getTsconfigCacheKey(resolvedTsConfigPath, config);\n    let cached = this.tsconfigOptionsCache.get(tsconfigKey);\n\n    if (!cached) {\n      const read = this.readAngularTsconfigConfiguration(\n        resolvedTsConfigPath,\n        config,\n      );\n      cached = { options: read.options, rootNames: read.rootNames };\n      this.tsconfigOptionsCache.set(tsconfigKey, cached);\n      debugEmit('tsconfig root names loaded', {\n        resolvedTsConfigPath,\n        rootNameCount: read.rootNames.length,\n      });\n      debugEmitV('tsconfig root names', {\n        resolvedTsConfigPath,\n        rootNames: read.rootNames.map((file: string) => normalizePath(file)),\n      });\n    }\n\n    return cached;\n  }\n\n  collectExpandedTsconfigRoots(\n    resolvedTsConfigPath: string,\n    config: ResolvedConfig,\n    visited = new Set<string>(),\n  ): string[] {\n    const normalizedTsConfigPath = normalizePath(resolvedTsConfigPath);\n    if (visited.has(normalizedTsConfigPath)) {\n      return [];\n    }\n\n    const tsconfigKey = `${this.getTsconfigCacheKey(normalizedTsConfigPath, config)}|graph`;\n    const cached = this.tsconfigGraphRootCache.get(tsconfigKey);\n    if (cached) {\n      return cached;\n    }\n\n    visited.add(normalizedTsConfigPath);\n\n    const read = this.readAngularTsconfigConfiguration(\n      normalizedTsConfigPath,\n      config,\n    );\n    const rawTsconfig = (ts.readConfigFile(\n      normalizedTsConfigPath,\n      ts.sys.readFile,\n    ).config ?? {}) as {\n      compilerOptions?: {\n        baseUrl?: unknown;\n        paths?: Record<string, string[]>;\n      };\n      references?: Array<{ path?: unknown }>;\n    };\n\n    const expandedRoots = new Set(\n      read.rootNames.map((file: string) => normalizePath(file)),\n    );\n    const pathRoots = collectTsconfigPathRoots(\n      normalizedTsConfigPath,\n      read.options,\n      rawTsconfig,\n    );\n    for (const pathRoot of pathRoots) {\n      expandedRoots.add(pathRoot);\n    }\n\n    const referenceConfigs = (rawTsconfig.references ?? [])\n      .flatMap((reference) =>\n        typeof reference.path === 'string'\n          ? [\n              resolveReferenceTsconfigPath(\n                reference.path,\n                normalizedTsConfigPath,\n              ),\n            ]\n          : [],\n      )\n      .filter((reference): reference is string => !!reference);\n\n    for (const referenceConfig of referenceConfigs) {\n      for (const referenceRoot of this.collectExpandedTsconfigRoots(\n        referenceConfig,\n        config,\n        visited,\n      )) {\n        expandedRoots.add(referenceRoot);\n      }\n    }\n\n    const expandedRootList = [...expandedRoots];\n    this.tsconfigGraphRootCache.set(tsconfigKey, expandedRootList);\n    debugEmit('expanded tsconfig graph roots', {\n      resolvedTsConfigPath: normalizedTsConfigPath,\n      directRootNameCount: read.rootNames.length,\n      pathRootCount: pathRoots.length,\n      referenceConfigCount: referenceConfigs.length,\n      expandedRootCount: expandedRootList.length,\n    });\n    debugEmitV('expanded tsconfig graph root files', {\n      resolvedTsConfigPath: normalizedTsConfigPath,\n      pathRoots,\n      referenceConfigs,\n      rootNames: expandedRootList,\n    });\n\n    return expandedRootList;\n  }\n\n  private getTsconfigCacheKey(\n    resolvedTsConfigPath: string,\n    config: ResolvedConfig,\n  ): string {\n    const isProd = config.mode === 'production';\n    return [\n      resolvedTsConfigPath,\n      isProd ? 'prod' : 'dev',\n      this.options.isTest ? 'test' : 'app',\n      config.build?.lib ? 'lib' : 'nolib',\n      !isProd || config.build?.sourcemap ? 'maps' : 'nomaps',\n      this.options.liveReload ? 'live-reload' : 'no-live-reload',\n    ].join('|');\n  }\n\n  private findIncludes(): string[] {\n    const globs = this.includeGlobs.map((glob) =>\n      normalizeIncludeGlob(this.options.workspaceRoot, glob),\n    );\n    const files = globSync(globs, { dot: true, absolute: true });\n    debugEmit('include discovery', {\n      patternCount: globs.length,\n      fileCount: files.length,\n    });\n    debugEmitV('include discovery files', {\n      globs,\n      files: files.map((file) => normalizePath(file)),\n    });\n    return files;\n  }\n}\n\nexport function normalizeIncludeGlob(\n  workspaceRoot: string,\n  glob: string,\n): string {\n  const normalizedWorkspaceRoot = normalizePath(resolve(workspaceRoot));\n  const normalizedGlob = normalizePath(glob);\n\n  if (\n    normalizedGlob === normalizedWorkspaceRoot ||\n    normalizedGlob.startsWith(`${normalizedWorkspaceRoot}/`)\n  ) {\n    return normalizedGlob;\n  }\n\n  if (normalizedGlob.startsWith('/')) {\n    return `${normalizedWorkspaceRoot}${normalizedGlob}`;\n  }\n\n  return normalizePath(resolve(normalizedWorkspaceRoot, normalizedGlob));\n}\n\nfunction resolveReferenceTsconfigPath(\n  referencePath: string,\n  ownerTsconfigPath: string,\n): string | undefined {\n  const ownerDir = dirname(ownerTsconfigPath);\n  const resolvedReference = normalizePath(\n    isAbsolute(referencePath)\n      ? referencePath\n      : resolve(ownerDir, referencePath),\n  );\n\n  if (existsSync(resolvedReference)) {\n    try {\n      if (statSync(resolvedReference).isDirectory()) {\n        const nestedTsconfig = join(resolvedReference, 'tsconfig.json');\n        return existsSync(nestedTsconfig)\n          ? normalizePath(nestedTsconfig)\n          : undefined;\n      }\n    } catch {\n      return undefined;\n    }\n    return resolvedReference;\n  }\n\n  if (!resolvedReference.endsWith('.json')) {\n    const asJson = `${resolvedReference}.json`;\n    if (existsSync(asJson)) {\n      return normalizePath(asJson);\n    }\n    const nestedTsconfig = join(resolvedReference, 'tsconfig.json');\n    if (existsSync(nestedTsconfig)) {\n      return normalizePath(nestedTsconfig);\n    }\n  }\n\n  return undefined;\n}\n\nfunction collectTsconfigPathRoots(\n  resolvedTsConfigPath: string,\n  options: any,\n  rawTsconfig: {\n    compilerOptions?: {\n      baseUrl?: unknown;\n      paths?: Record<string, string[]>;\n    };\n  },\n): string[] {\n  const tsPaths = rawTsconfig.compilerOptions?.paths ?? options.paths;\n  if (!tsPaths) {\n    return [];\n  }\n\n  const tsconfigDir = dirname(resolvedTsConfigPath);\n  const configuredBaseUrl =\n    typeof options.baseUrl === 'string'\n      ? options.baseUrl\n      : typeof rawTsconfig.compilerOptions?.baseUrl === 'string'\n        ? rawTsconfig.compilerOptions.baseUrl\n        : undefined;\n  const resolvedBaseUrl = configuredBaseUrl\n    ? isAbsolute(configuredBaseUrl)\n      ? configuredBaseUrl\n      : resolve(tsconfigDir, configuredBaseUrl)\n    : tsconfigDir;\n  const discoveredRoots = new Set<string>();\n\n  for (const targets of Object.values(tsPaths)) {\n    for (const target of targets as string[]) {\n      const resolvedTarget = normalizePath(\n        isAbsolute(target) ? target : resolve(resolvedBaseUrl, target),\n      );\n\n      if (target.includes('*')) {\n        for (const match of globSync(resolvedTarget, {\n          dot: true,\n          absolute: true,\n        })) {\n          discoveredRoots.add(normalizePath(match));\n        }\n        continue;\n      }\n\n      if (existsSync(resolvedTarget)) {\n        discoveredRoots.add(resolvedTarget);\n      }\n    }\n  }\n\n  return [...discoveredRoots];\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,IAAM,KADU,cAAc,OAAO,KAAK,IAAI,CAC3B,aAAa;AAShC,IAAa,mBAAb,MAA8B;CAC5B,eAAiC,EAAE;CACnC,uCAA+B,IAAI,KAGhC;CACH,yCAAiC,IAAI,KAAuB;CAC5D,sBAAwC,EAAE;CAE1C,YAAY,SAA0C;AAAlC,OAAA,UAAA;;;;;;CAMpB,uBAAuB,OAAuB;AAC5C,MACE,MAAM,WAAW,KAAK,oBAAoB,UAC1C,MAAM,OAAO,MAAM,UAAU,SAAS,KAAK,oBAAoB,OAAO,CAEtE;AAEF,OAAK,sBAAsB,CAAC,GAAG,MAAM;AACrC,OAAK,wBAAwB;;CAG/B,IAAY,eAAyB;AACnC,SAAO,CAAC,GAAG,KAAK,QAAQ,SAAS,GAAG,KAAK,oBAAoB;;CAG/D,yBAA+B;AAC7B,OAAK,eAAe,EAAE;;CAGxB,2BAAiC;AAC/B,OAAK,qBAAqB,OAAO;AACjC,OAAK,uBAAuB,OAAO;;CAGrC,gBAAsB;AACpB,OAAK,wBAAwB;AAC7B,OAAK,0BAA0B;;CAGjC,qBAA+B;AAC7B,MAAI,KAAK,aAAa,SAAS,KAAK,KAAK,aAAa,WAAW,GAAG;AAClE,QAAK,eAAe,KAAK,cAAc;AACvC,aAAU,2BAA2B,EACnC,WAAW,KAAK,aAAa,QAC9B,CAAC;;AAEJ,SAAO,KAAK;;CAGd,iCACE,sBACA,QACA;EAEA,MAAM,iBAAiB,EADR,OAAO,SAAS,iBACG,CAAC,CAAC,OAAO,OAAO;AAClD,SAAO,YAAY,kBAAkB,sBAAsB;GACzD,yBAAyB;GACzB,QAAQ,KAAA;GACR,WAAW;GACX,iBAAiB;GACjB,eAAe;GACf,aAAa;GACb,gBAAgB;GAChB,wBAAwB;GACxB,eAAe;GACf,wBAAwB;GACxB,eAAe;GACf,SAAS;GACT,YAAY;GACZ,gBAAgB;GAChB,gBAAgB;GACjB,CAAC;;CAGJ,yBACE,sBACA,QACuC;EACvC,MAAM,cAAc,KAAK,oBAAoB,sBAAsB,OAAO;EAC1E,IAAI,SAAS,KAAK,qBAAqB,IAAI,YAAY;AAEvD,MAAI,CAAC,QAAQ;GACX,MAAM,OAAO,KAAK,iCAChB,sBACA,OACD;AACD,YAAS;IAAE,SAAS,KAAK;IAAS,WAAW,KAAK;IAAW;AAC7D,QAAK,qBAAqB,IAAI,aAAa,OAAO;AAClD,aAAU,8BAA8B;IACtC;IACA,eAAe,KAAK,UAAU;IAC/B,CAAC;AACF,cAAW,uBAAuB;IAChC;IACA,WAAW,KAAK,UAAU,KAAK,SAAiB,cAAc,KAAK,CAAC;IACrE,CAAC;;AAGJ,SAAO;;CAGT,6BACE,sBACA,QACA,0BAAU,IAAI,KAAa,EACjB;EACV,MAAM,yBAAyB,cAAc,qBAAqB;AAClE,MAAI,QAAQ,IAAI,uBAAuB,CACrC,QAAO,EAAE;EAGX,MAAM,cAAc,GAAG,KAAK,oBAAoB,wBAAwB,OAAO,CAAC;EAChF,MAAM,SAAS,KAAK,uBAAuB,IAAI,YAAY;AAC3D,MAAI,OACF,QAAO;AAGT,UAAQ,IAAI,uBAAuB;EAEnC,MAAM,OAAO,KAAK,iCAChB,wBACA,OACD;EACD,MAAM,cAAe,GAAG,eACtB,wBACA,GAAG,IAAI,SACR,CAAC,UAAU,EAAE;EAQd,MAAM,gBAAgB,IAAI,IACxB,KAAK,UAAU,KAAK,SAAiB,cAAc,KAAK,CAAC,CAC1D;EACD,MAAM,YAAY,yBAChB,wBACA,KAAK,SACL,YACD;AACD,OAAK,MAAM,YAAY,UACrB,eAAc,IAAI,SAAS;EAG7B,MAAM,oBAAoB,YAAY,cAAc,EAAE,EACnD,SAAS,cACR,OAAO,UAAU,SAAS,WACtB,CACE,6BACE,UAAU,MACV,uBACD,CACF,GACD,EAAE,CACP,CACA,QAAQ,cAAmC,CAAC,CAAC,UAAU;AAE1D,OAAK,MAAM,mBAAmB,iBAC5B,MAAK,MAAM,iBAAiB,KAAK,6BAC/B,iBACA,QACA,QACD,CACC,eAAc,IAAI,cAAc;EAIpC,MAAM,mBAAmB,CAAC,GAAG,cAAc;AAC3C,OAAK,uBAAuB,IAAI,aAAa,iBAAiB;AAC9D,YAAU,iCAAiC;GACzC,sBAAsB;GACtB,qBAAqB,KAAK,UAAU;GACpC,eAAe,UAAU;GACzB,sBAAsB,iBAAiB;GACvC,mBAAmB,iBAAiB;GACrC,CAAC;AACF,aAAW,sCAAsC;GAC/C,sBAAsB;GACtB;GACA;GACA,WAAW;GACZ,CAAC;AAEF,SAAO;;CAGT,oBACE,sBACA,QACQ;EACR,MAAM,SAAS,OAAO,SAAS;AAC/B,SAAO;GACL;GACA,SAAS,SAAS;GAClB,KAAK,QAAQ,SAAS,SAAS;GAC/B,OAAO,OAAO,MAAM,QAAQ;GAC5B,CAAC,UAAU,OAAO,OAAO,YAAY,SAAS;GAC9C,KAAK,QAAQ,aAAa,gBAAgB;GAC3C,CAAC,KAAK,IAAI;;CAGb,eAAiC;EAC/B,MAAM,QAAQ,KAAK,aAAa,KAAK,SACnC,qBAAqB,KAAK,QAAQ,eAAe,KAAK,CACvD;EACD,MAAM,QAAQ,SAAS,OAAO;GAAE,KAAK;GAAM,UAAU;GAAM,CAAC;AAC5D,YAAU,qBAAqB;GAC7B,cAAc,MAAM;GACpB,WAAW,MAAM;GAClB,CAAC;AACF,aAAW,2BAA2B;GACpC;GACA,OAAO,MAAM,KAAK,SAAS,cAAc,KAAK,CAAC;GAChD,CAAC;AACF,SAAO;;;AAIX,SAAgB,qBACd,eACA,MACQ;CACR,MAAM,0BAA0B,cAAc,QAAQ,cAAc,CAAC;CACrE,MAAM,iBAAiB,cAAc,KAAK;AAE1C,KACE,mBAAmB,2BACnB,eAAe,WAAW,GAAG,wBAAwB,GAAG,CAExD,QAAO;AAGT,KAAI,eAAe,WAAW,IAAI,CAChC,QAAO,GAAG,0BAA0B;AAGtC,QAAO,cAAc,QAAQ,yBAAyB,eAAe,CAAC;;AAGxE,SAAS,6BACP,eACA,mBACoB;CACpB,MAAM,WAAW,QAAQ,kBAAkB;CAC3C,MAAM,oBAAoB,cACxB,WAAW,cAAc,GACrB,gBACA,QAAQ,UAAU,cAAc,CACrC;AAED,KAAI,WAAW,kBAAkB,EAAE;AACjC,MAAI;AACF,OAAI,SAAS,kBAAkB,CAAC,aAAa,EAAE;IAC7C,MAAM,iBAAiB,KAAK,mBAAmB,gBAAgB;AAC/D,WAAO,WAAW,eAAe,GAC7B,cAAc,eAAe,GAC7B,KAAA;;UAEA;AACN;;AAEF,SAAO;;AAGT,KAAI,CAAC,kBAAkB,SAAS,QAAQ,EAAE;EACxC,MAAM,SAAS,GAAG,kBAAkB;AACpC,MAAI,WAAW,OAAO,CACpB,QAAO,cAAc,OAAO;EAE9B,MAAM,iBAAiB,KAAK,mBAAmB,gBAAgB;AAC/D,MAAI,WAAW,eAAe,CAC5B,QAAO,cAAc,eAAe;;;AAO1C,SAAS,yBACP,sBACA,SACA,aAMU;CACV,MAAM,UAAU,YAAY,iBAAiB,SAAS,QAAQ;AAC9D,KAAI,CAAC,QACH,QAAO,EAAE;CAGX,MAAM,cAAc,QAAQ,qBAAqB;CACjD,MAAM,oBACJ,OAAO,QAAQ,YAAY,WACvB,QAAQ,UACR,OAAO,YAAY,iBAAiB,YAAY,WAC9C,YAAY,gBAAgB,UAC5B,KAAA;CACR,MAAM,kBAAkB,oBACpB,WAAW,kBAAkB,GAC3B,oBACA,QAAQ,aAAa,kBAAkB,GACzC;CACJ,MAAM,kCAAkB,IAAI,KAAa;AAEzC,MAAK,MAAM,WAAW,OAAO,OAAO,QAAQ,CAC1C,MAAK,MAAM,UAAU,SAAqB;EACxC,MAAM,iBAAiB,cACrB,WAAW,OAAO,GAAG,SAAS,QAAQ,iBAAiB,OAAO,CAC/D;AAED,MAAI,OAAO,SAAS,IAAI,EAAE;AACxB,QAAK,MAAM,SAAS,SAAS,gBAAgB;IAC3C,KAAK;IACL,UAAU;IACX,CAAC,CACA,iBAAgB,IAAI,cAAc,MAAM,CAAC;AAE3C;;AAGF,MAAI,WAAW,eAAe,CAC5B,iBAAgB,IAAI,eAAe;;AAKzC,QAAO,CAAC,GAAG,gBAAgB"}

package/src/lib/utils/virtual-ids.d.ts

@@ -0,0 +1,4 @@
+export declare const VIRTUAL_RAW_PREFIX = "virtual:@analogjs/vite-plugin-angular:raw:";
+export declare function toVirtualRawId(absPath: string): string;
+export declare function isVirtualRawId(id: string): boolean;
+export declare function fromVirtualRawId(id: string): string;

package/src/lib/utils/virtual-ids.js

@@ -0,0 +1,23 @@
+//#region packages/vite-plugin-angular/src/lib/utils/virtual-ids.ts
+var VIRTUAL_RAW_PREFIX = "virtual:@analogjs/vite-plugin-angular:raw:";
+function encode(absPath) {
+	return Buffer.from(absPath, "utf-8").toString("base64url");
+}
+function decode(encoded) {
+	return Buffer.from(encoded, "base64url").toString("utf-8");
+}
+function toVirtualRawId(absPath) {
+	return `${VIRTUAL_RAW_PREFIX}${encode(absPath)}`;
+}
+function isVirtualRawId(id) {
+	return (id.startsWith("\0") ? id.slice(1) : id).startsWith(VIRTUAL_RAW_PREFIX);
+}
+function fromVirtualRawId(id) {
+	const normalizedId = id.startsWith("\0") ? id.slice(1) : id;
+	if (!normalizedId.startsWith("virtual:@analogjs/vite-plugin-angular:raw:")) throw new Error(`Invalid virtual raw id: ${id}`);
+	return decode(normalizedId.slice(42));
+}
+//#endregion
+export { VIRTUAL_RAW_PREFIX, fromVirtualRawId, isVirtualRawId, toVirtualRawId };
+
+//# sourceMappingURL=virtual-ids.js.map

package/src/lib/utils/virtual-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-ids.js","names":[],"sources":["../../../../src/lib/utils/virtual-ids.ts"],"sourcesContent":["// Virtual module id helpers for external component resources (template files).\n// Routing through virtual ids keeps Vite's built-in plugins (vite:asset, the\n// server.fs Denied ID check) out of the picture: the id Vite sees has no\n// file extension, so extension-based matchers never fire, and it does not\n// match the /[?&](raw|inline)\\b/ security regex.\n//\n// Style ?inline imports now flow through Vite's native CSS pipeline via\n// safeModulePaths (see safe-module-paths.ts). Only template ?raw imports\n// still use virtual ids. See #2263 / #2283 / #2310.\n\nexport const VIRTUAL_RAW_PREFIX = 'virtual:@analogjs/vite-plugin-angular:raw:';\n\nfunction encode(absPath: string): string {\n  return Buffer.from(absPath, 'utf-8').toString('base64url');\n}\n\nfunction decode(encoded: string): string {\n  return Buffer.from(encoded, 'base64url').toString('utf-8');\n}\n\nexport function toVirtualRawId(absPath: string): string {\n  return `${VIRTUAL_RAW_PREFIX}${encode(absPath)}`;\n}\n\nexport function isVirtualRawId(id: string): boolean {\n  const stripped = id.startsWith('\\0') ? id.slice(1) : id;\n  return stripped.startsWith(VIRTUAL_RAW_PREFIX);\n}\n\nexport function fromVirtualRawId(id: string): string {\n  const normalizedId = id.startsWith('\\0') ? id.slice(1) : id;\n  if (!normalizedId.startsWith(VIRTUAL_RAW_PREFIX)) {\n    throw new Error(`Invalid virtual raw id: ${id}`);\n  }\n  return decode(normalizedId.slice(VIRTUAL_RAW_PREFIX.length));\n}\n"],"mappings":";AAUA,IAAa,qBAAqB;AAElC,SAAS,OAAO,SAAyB;AACvC,QAAO,OAAO,KAAK,SAAS,QAAQ,CAAC,SAAS,YAAY;;AAG5D,SAAS,OAAO,SAAyB;AACvC,QAAO,OAAO,KAAK,SAAS,YAAY,CAAC,SAAS,QAAQ;;AAG5D,SAAgB,eAAe,SAAyB;AACtD,QAAO,GAAG,qBAAqB,OAAO,QAAQ;;AAGhD,SAAgB,eAAe,IAAqB;AAElD,SADiB,GAAG,WAAW,KAAK,GAAG,GAAG,MAAM,EAAE,GAAG,IACrC,WAAW,mBAAmB;;AAGhD,SAAgB,iBAAiB,IAAoB;CACnD,MAAM,eAAe,GAAG,WAAW,KAAK,GAAG,GAAG,MAAM,EAAE,GAAG;AACzD,KAAI,CAAC,aAAa,WAAA,6CAA8B,CAC9C,OAAM,IAAI,MAAM,2BAA2B,KAAK;AAElD,QAAO,OAAO,aAAa,MAAM,GAA0B,CAAC"}

package/src/lib/utils/virtual-resources.d.ts

@@ -0,0 +1,19 @@
+interface PluginContextLike {
+	addWatchFile(path: string): void;
+}
+/**
+* Rewrite a user `.html?raw` import to a virtual raw id. Returns undefined
+* when the id doesn't match, so callers can fall through to the next check.
+*
+* Routed through a virtual id (rather than `?analog-raw`) so the path Vite
+* sees has no file extension — keeps vite:asset / vite:css from re-tagging
+* the id before our load hook runs.
+*/
+export declare function rewriteHtmlRawImport(id: string, importer: string | undefined): string | undefined;
+/**
+* Load a virtual raw module: reads the backing file, registers it for HMR
+* watching, and returns its content as a default-exported string. Returns
+* undefined when the id is not a virtual raw id.
+*/
+export declare function loadVirtualRawModule(ctx: PluginContextLike, id: string): Promise<string | undefined>;
+export {};

package/src/lib/utils/virtual-resources.js

@@ -0,0 +1,38 @@
+import { fromVirtualRawId, isVirtualRawId, toVirtualRawId } from "./virtual-ids.js";
+import { promises } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { normalizePath } from "vite";
+//#region packages/vite-plugin-angular/src/lib/utils/virtual-resources.ts
+function resolveImportPath(id, importer) {
+	const filePath = id.split("?")[0];
+	return isAbsolute(filePath) ? normalizePath(filePath) : importer ? normalizePath(resolve(dirname(importer), filePath)) : void 0;
+}
+/**
+* Rewrite a user `.html?raw` import to a virtual raw id. Returns undefined
+* when the id doesn't match, so callers can fall through to the next check.
+*
+* Routed through a virtual id (rather than `?analog-raw`) so the path Vite
+* sees has no file extension — keeps vite:asset / vite:css from re-tagging
+* the id before our load hook runs.
+*/
+function rewriteHtmlRawImport(id, importer) {
+	if (!id.includes(".html?raw")) return void 0;
+	const resolved = resolveImportPath(id, importer);
+	return resolved ? toVirtualRawId(resolved) : void 0;
+}
+/**
+* Load a virtual raw module: reads the backing file, registers it for HMR
+* watching, and returns its content as a default-exported string. Returns
+* undefined when the id is not a virtual raw id.
+*/
+async function loadVirtualRawModule(ctx, id) {
+	if (!isVirtualRawId(id)) return void 0;
+	const filePath = fromVirtualRawId(id);
+	ctx.addWatchFile(filePath);
+	const content = await promises.readFile(filePath, "utf-8");
+	return `export default ${JSON.stringify(content)}`;
+}
+//#endregion
+export { loadVirtualRawModule, rewriteHtmlRawImport };
+
+//# sourceMappingURL=virtual-resources.js.map

package/src/lib/utils/virtual-resources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual-resources.js","names":[],"sources":["../../../../src/lib/utils/virtual-resources.ts"],"sourcesContent":["// Shared Vite plugin helpers for routing component resources (templates)\n// through virtual module ids. Both angular-vite-plugin and fast-compile-plugin\n// use these so the rewriting + loading behavior stays in sync between them.\n//\n// Style ?inline imports now flow through Vite's native CSS pipeline via\n// safeModulePaths (see safe-module-paths.ts). Only template ?raw imports\n// still use virtual ids.\n\nimport { promises as fsPromises } from 'node:fs';\nimport { dirname, isAbsolute, resolve } from 'node:path';\nimport { normalizePath } from 'vite';\n\nimport {\n  fromVirtualRawId,\n  isVirtualRawId,\n  toVirtualRawId,\n} from './virtual-ids.js';\n\ninterface PluginContextLike {\n  addWatchFile(path: string): void;\n}\n\nfunction resolveImportPath(\n  id: string,\n  importer: string | undefined,\n): string | undefined {\n  const filePath = id.split('?')[0];\n  return isAbsolute(filePath)\n    ? normalizePath(filePath)\n    : importer\n      ? normalizePath(resolve(dirname(importer), filePath))\n      : undefined;\n}\n\n/**\n * Rewrite a user `.html?raw` import to a virtual raw id. Returns undefined\n * when the id doesn't match, so callers can fall through to the next check.\n *\n * Routed through a virtual id (rather than `?analog-raw`) so the path Vite\n * sees has no file extension — keeps vite:asset / vite:css from re-tagging\n * the id before our load hook runs.\n */\nexport function rewriteHtmlRawImport(\n  id: string,\n  importer: string | undefined,\n): string | undefined {\n  if (!id.includes('.html?raw')) return undefined;\n  const resolved = resolveImportPath(id, importer);\n  return resolved ? toVirtualRawId(resolved) : undefined;\n}\n\n/**\n * Load a virtual raw module: reads the backing file, registers it for HMR\n * watching, and returns its content as a default-exported string. Returns\n * undefined when the id is not a virtual raw id.\n */\nexport async function loadVirtualRawModule(\n  ctx: PluginContextLike,\n  id: string,\n): Promise<string | undefined> {\n  if (!isVirtualRawId(id)) return undefined;\n  const filePath = fromVirtualRawId(id);\n  ctx.addWatchFile(filePath);\n  const content = await fsPromises.readFile(filePath, 'utf-8');\n  return `export default ${JSON.stringify(content)}`;\n}\n"],"mappings":";;;;;AAsBA,SAAS,kBACP,IACA,UACoB;CACpB,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC;AAC/B,QAAO,WAAW,SAAS,GACvB,cAAc,SAAS,GACvB,WACE,cAAc,QAAQ,QAAQ,SAAS,EAAE,SAAS,CAAC,GACnD,KAAA;;;;;;;;;;AAWR,SAAgB,qBACd,IACA,UACoB;AACpB,KAAI,CAAC,GAAG,SAAS,YAAY,CAAE,QAAO,KAAA;CACtC,MAAM,WAAW,kBAAkB,IAAI,SAAS;AAChD,QAAO,WAAW,eAAe,SAAS,GAAG,KAAA;;;;;;;AAQ/C,eAAsB,qBACpB,KACA,IAC6B;AAC7B,KAAI,CAAC,eAAe,GAAG,CAAE,QAAO,KAAA;CAChC,MAAM,WAAW,iBAAiB,GAAG;AACrC,KAAI,aAAa,SAAS;CAC1B,MAAM,UAAU,MAAM,SAAW,SAAS,UAAU,QAAQ;AAC5D,QAAO,kBAAkB,KAAK,UAAU,QAAQ"}

package/src/lib/virtual-modules-plugin.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+export interface VirtualModulesPluginOptions {
+	jit: boolean;
+}
+export declare function virtualModulesPlugin(pluginOptions: VirtualModulesPluginOptions): Plugin;