@analogjs/vite-plugin-angular 3.0.0-alpha.59 → 3.0.0-alpha.60

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

@@ -0,0 +1,43 @@
+/**
+* The `{ get, put }` shape `@angular/build`'s `JavaScriptTransformer`
+* accepts as its third constructor argument. Keys are SHA-256 digests 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 fs from "node:fs";
+import * as path$1 from "node:path";
+import * as crypto from "node:crypto";
+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 as its third constructor argument. Keys are SHA-256 digests 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"}