@bamboocss/parser 1.46.0 → 1.46.2

package/dist/index.cjs

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let ts_morph = require("ts-morph");
 let _bamboocss_extractor = require("@bamboocss/extractor");
 let _bamboocss_shared = require("@bamboocss/shared");
+let node_crypto = require("node:crypto");
 let _bamboocss_logger = require("@bamboocss/logger");
 let ts_pattern = require("ts-pattern");
 let _bamboocss_config_ts_path = require("@bamboocss/config/ts-path");
@@ -612,6 +613,52 @@ const walkImports = (sourceFile, imports, resolveModule, seen) => {
 */
 const importedRecipeBindings = (sourceFile, imports, resolveModule) => walkImports(sourceFile, imports, resolveModule, new Set([sourceFile])).bindings;
 //#endregion
+//#region src/export-read-digest.ts
+/**
+* A digest of what one exported name resolves to right now, or `undefined` when the answer
+* cannot be pinned down.
+*
+* This is the witness the read-verification protocol compares: a dependent records the digest
+* of every cross-file value it folded, and an edit to the exporting file is verified by
+* recomputing the same digest through the same resolution path. The two sides must therefore
+* be the *same function* -- recorded at parse time, recomputed at verification time -- or
+* equal values would compare unequal and every edit would fall back to a full re-fold.
+*
+* `undefined` is the conservative verdict, and everything unusual maps to it: a missing
+* initializer, an evaluation the bare context cannot resolve (a value built through the
+* parser's evaluation environment, say), a conditional value, a non-serializable result, a
+* throw. An export that stopped existing is *not* unknown -- it digests to a distinct
+* sentinel, so its consumers read as changed rather than unverifiable.
+*
+* Serialized with insertion order preserved: property order is part of a style value's
+* meaning, so reordering keys must read as a change. `undefined` leaves inside the value are
+* kept visible through a sentinel, since `JSON.stringify` would otherwise erase the
+* difference between an unresolvable member and an absent one.
+*/
+const digestExportValue = (sourceFile, exportedName, resolveModule, onCrossing) => {
+	if (!sourceFile) return "bamboo:module-missing";
+	const boxCtx = {
+		flags: { skipTraverseFiles: false },
+		resolveModule,
+		recordDependency: onCrossing
+	};
+	try {
+		const declaration = (0, _bamboocss_extractor.getExportedVarDeclarationWithName)(exportedName, sourceFile, [], boxCtx);
+		if (!declaration) return "bamboo:export-missing";
+		const initializer = declaration.getInitializer?.();
+		if (!initializer) return void 0;
+		const box = (0, _bamboocss_extractor.maybeBoxNode)(initializer, [], boxCtx);
+		if (!box || Array.isArray(box)) return void 0;
+		const unboxed = (0, _bamboocss_extractor.unbox)(box);
+		if (unboxed.conditions.length || unboxed.spreadConditions.length) return void 0;
+		const json = JSON.stringify(unboxed.raw, (_key, value) => value === void 0 ? "bamboo:undefined" : value);
+		if (json === void 0) return void 0;
+		return (0, node_crypto.createHash)("sha256").update(json).digest("base64");
+	} catch {
+		return;
+	}
+};
+//#endregion
 //#region src/get-import-declarations.ts
 function getImportDeclarations(context, sourceFile) {
 	const { imports, tsOptions } = context;
@@ -1048,6 +1095,16 @@ var ParserResult = class {
 	addDependency(filePath) {
 		this.dependencies.add(filePath.replaceAll("\\", "/"));
 	}
+	/** Cross-file value reads this extraction performed, with the digests read at parse time. */
+	exportReads = [];
+	/** @internal Set once by the parser after extraction, digests computed on warm caches. */
+	setExportReads(reads) {
+		this.exportReads = reads;
+	}
+	/** @internal The reads a consumer can verify instead of re-folding; see the Vite plugin. */
+	getExportReads() {
+		return this.exportReads;
+	}
 	/**
 	* Local source paths crossed while resolving values this extraction actually encoded.
 	*
@@ -1173,6 +1230,8 @@ function createParser(context) {
 			});
 		};
 		const recordDependency = (filePath) => parserResult.addDependency(filePath);
+		const exportReadPairs = /* @__PURE__ */ new Set();
+		const recordExportRead = (filePath, exportedName) => exportReadPairs.add(`${filePath.replaceAll("\\", "/")}\u0000${exportedName}`);
 		(0, _bamboocss_extractor.extract)({
 			ast: sourceFile,
 			tokens: context.tokens ? {
@@ -1223,6 +1282,7 @@ function createParser(context) {
 			},
 			flags: { skipTraverseFiles: false },
 			recordDependency,
+			recordExportRead,
 			resolveModule
 		}).forEach((result, alias) => {
 			const name = file.getName(file.normalizeFnName(alias));
@@ -1315,6 +1375,19 @@ function createParser(context) {
 			});
 		});
 		parserResult.deadCalls = file.getDeadCalls();
+		if (exportReadPairs.size) {
+			const project = sourceFile.getProject();
+			parserResult.setExportReads([...exportReadPairs].map((pair) => {
+				const at = pair.indexOf("\0");
+				const file = pair.slice(0, at);
+				const name = pair.slice(at + 1);
+				return {
+					file,
+					name,
+					digest: digestExportValue(project.getSourceFile(file), name, resolveModule)
+				};
+			}));
+		}
 		return parserResult;
 	};
 }
@@ -1680,8 +1753,28 @@ var Project = class {
 	* dependency edge; now it would also leave a recipe permanently invisible to the module
 	* importing it, since resolution is what finds one.
 	*/
-	invalidate = (fileTreeChanged = true) => {
+	invalidate = (fileTreeChanged = true, changedPath) => {
 		this.#assertNotLoading();
+		/**
+		* A content edit to a file the project already holds invalidates *by path* rather than
+		* dropping every memoized value. Each cache entry records the module paths its
+		* computation read — the same record the watch system replays into fold dependencies —
+		* so marking the edited path stale rejects exactly the entries whose value could have
+		* moved, while a value resolved without reading this file keeps its cache. The edited
+		* file's own entries need no marking: its re-parse retires their key nodes.
+		*
+		* That narrowing holds only for content: a file appearing or disappearing can change
+		* what a specifier resolves to without any recorded path's bytes moving — extension
+		* precedence, a new local shadowing a package — so tree changes keep the full clear.
+		* The recipe-origin memo records no read-set, so it is cleared on every event either
+		* way; per edit that is one walk rebuilt lazily, not the per-transform storm the
+		* identical-text no-op in `addSourceFile` exists to prevent.
+		*/
+		if (!fileTreeChanged && changedPath) {
+			(0, _bamboocss_extractor.invalidateDependencyPath)(this.normalizePath(changedPath));
+			clearImportedRecipeCache();
+			return;
+		}
 		invalidateResolutions();
 		if (fileTreeChanged) {
 			this.#moduleResolutionCache = void 0;
@@ -2234,7 +2327,7 @@ var Project = class {
 		if (existing && existing.getFullText() === content) return existing;
 		this.invalidateSourcePreparation(filePath, existing);
 		this.removedSourcePaths.delete(this.normalizePath(filePath));
-		this.invalidate(!existing);
+		this.invalidate(!existing, existing?.getFilePath());
 		return this.project.createSourceFile(filePath, content, {
 			overwrite: true,
 			scriptKind: scriptKindFor(filePath)
@@ -2253,11 +2346,22 @@ var Project = class {
 		}
 		return false;
 	};
+	/**
+	* The current digest of one exported value, for read verification.
+	*
+	* Same function and same resolver identity as the parse-time recording, which is what makes
+	* the comparison meaningful; see `digestExportValue`.
+	*/
+	digestExportRead = (filePath, exportedName, onCrossing) => {
+		this.#assertNotLoading();
+		this.#ensureSourceFiles();
+		return digestExportValue(this.getSourceFile(filePath), exportedName, this.resolveModule, onCrossing);
+	};
 	reloadSourceFile = (filePath) => {
 		this.#assertNotLoading();
 		this.#ensureSourceFiles();
-		this.invalidate(false);
 		const sourceFile = this.getSourceFile(filePath);
+		this.invalidate(false, sourceFile?.getFilePath());
 		if (!sourceFile) return;
 		this.invalidateSourcePreparation(filePath, sourceFile);
 		return sourceFile.refreshFromFileSystemSync();

package/dist/index.d.cts

@@ -357,6 +357,20 @@ declare class ParserResult implements ParserResultInterface {
   setFilePath(filePath: string): this;
   /** @internal Called only by the extractor-facing resolver, not by import classification. */
   addDependency(filePath: string): void;
+  /** Cross-file value reads this extraction performed, with the digests read at parse time. */
+  private exportReads;
+  /** @internal Set once by the parser after extraction, digests computed on warm caches. */
+  setExportReads(reads: Array<{
+    file: string;
+    name: string;
+    digest: string | undefined;
+  }>): void;
+  /** @internal The reads a consumer can verify instead of re-folding; see the Vite plugin. */
+  getExportReads(): ReadonlyArray<{
+    file: string;
+    name: string;
+    digest: string | undefined;
+  }>;
   /**
    * Local source paths crossed while resolving values this extraction actually encoded.
    *
@@ -584,6 +598,13 @@ declare class Project {
   createSourceFiles: () => void;
   addSourceFile: (filePath: string, content: string) => SourceFile;
   removeSourceFile: (filePath: string) => boolean;
+  /**
+   * The current digest of one exported value, for read verification.
+   *
+   * Same function and same resolver identity as the parse-time recording, which is what makes
+   * the comparison meaningful; see `digestExportValue`.
+   */
+  digestExportRead: (filePath: string, exportedName: string, onCrossing?: (crossedPath: string) => void) => string | undefined;
   reloadSourceFile: (filePath: string) => FileSystemRefreshResult | undefined;
   reloadSourceFiles: () => void;
   get readFile(): (filePath: string) => string;

package/dist/index.d.mts

@@ -357,6 +357,20 @@ declare class ParserResult implements ParserResultInterface {
   setFilePath(filePath: string): this;
   /** @internal Called only by the extractor-facing resolver, not by import classification. */
   addDependency(filePath: string): void;
+  /** Cross-file value reads this extraction performed, with the digests read at parse time. */
+  private exportReads;
+  /** @internal Set once by the parser after extraction, digests computed on warm caches. */
+  setExportReads(reads: Array<{
+    file: string;
+    name: string;
+    digest: string | undefined;
+  }>): void;
+  /** @internal The reads a consumer can verify instead of re-folding; see the Vite plugin. */
+  getExportReads(): ReadonlyArray<{
+    file: string;
+    name: string;
+    digest: string | undefined;
+  }>;
   /**
    * Local source paths crossed while resolving values this extraction actually encoded.
    *
@@ -584,6 +598,13 @@ declare class Project {
   createSourceFiles: () => void;
   addSourceFile: (filePath: string, content: string) => SourceFile;
   removeSourceFile: (filePath: string) => boolean;
+  /**
+   * The current digest of one exported value, for read verification.
+   *
+   * Same function and same resolver identity as the parse-time recording, which is what makes
+   * the comparison meaningful; see `digestExportValue`.
+   */
+  digestExportRead: (filePath: string, exportedName: string, onCrossing?: (crossedPath: string) => void) => string | undefined;
   reloadSourceFile: (filePath: string) => FileSystemRefreshResult | undefined;
   reloadSourceFiles: () => void;
   get readFile(): (filePath: string) => string;

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { Node, Project as Project$1, ScriptKind, ts } from "ts-morph";
-import { box, clearBoxNodeCache, extract, unbox, unwrapExpression } from "@bamboocss/extractor";
+import { box, clearBoxNodeCache, extract, getExportedVarDeclarationWithName, invalidateDependencyPath, maybeBoxNode, unbox, unwrapExpression } from "@bamboocss/extractor";
 import { BambooError, compact, createPatternFns, getOrCreateSet } from "@bamboocss/shared";
+import { createHash } from "node:crypto";
 import { logger } from "@bamboocss/logger";
 import { match } from "ts-pattern";
 import { resolveTsPathPattern } from "@bamboocss/config/ts-path";
@@ -611,6 +612,52 @@ const walkImports = (sourceFile, imports, resolveModule, seen) => {
 */
 const importedRecipeBindings = (sourceFile, imports, resolveModule) => walkImports(sourceFile, imports, resolveModule, new Set([sourceFile])).bindings;
 //#endregion
+//#region src/export-read-digest.ts
+/**
+* A digest of what one exported name resolves to right now, or `undefined` when the answer
+* cannot be pinned down.
+*
+* This is the witness the read-verification protocol compares: a dependent records the digest
+* of every cross-file value it folded, and an edit to the exporting file is verified by
+* recomputing the same digest through the same resolution path. The two sides must therefore
+* be the *same function* -- recorded at parse time, recomputed at verification time -- or
+* equal values would compare unequal and every edit would fall back to a full re-fold.
+*
+* `undefined` is the conservative verdict, and everything unusual maps to it: a missing
+* initializer, an evaluation the bare context cannot resolve (a value built through the
+* parser's evaluation environment, say), a conditional value, a non-serializable result, a
+* throw. An export that stopped existing is *not* unknown -- it digests to a distinct
+* sentinel, so its consumers read as changed rather than unverifiable.
+*
+* Serialized with insertion order preserved: property order is part of a style value's
+* meaning, so reordering keys must read as a change. `undefined` leaves inside the value are
+* kept visible through a sentinel, since `JSON.stringify` would otherwise erase the
+* difference between an unresolvable member and an absent one.
+*/
+const digestExportValue = (sourceFile, exportedName, resolveModule, onCrossing) => {
+	if (!sourceFile) return "bamboo:module-missing";
+	const boxCtx = {
+		flags: { skipTraverseFiles: false },
+		resolveModule,
+		recordDependency: onCrossing
+	};
+	try {
+		const declaration = getExportedVarDeclarationWithName(exportedName, sourceFile, [], boxCtx);
+		if (!declaration) return "bamboo:export-missing";
+		const initializer = declaration.getInitializer?.();
+		if (!initializer) return void 0;
+		const box = maybeBoxNode(initializer, [], boxCtx);
+		if (!box || Array.isArray(box)) return void 0;
+		const unboxed = unbox(box);
+		if (unboxed.conditions.length || unboxed.spreadConditions.length) return void 0;
+		const json = JSON.stringify(unboxed.raw, (_key, value) => value === void 0 ? "bamboo:undefined" : value);
+		if (json === void 0) return void 0;
+		return createHash("sha256").update(json).digest("base64");
+	} catch {
+		return;
+	}
+};
+//#endregion
 //#region src/get-import-declarations.ts
 function getImportDeclarations(context, sourceFile) {
 	const { imports, tsOptions } = context;
@@ -1047,6 +1094,16 @@ var ParserResult = class {
 	addDependency(filePath) {
 		this.dependencies.add(filePath.replaceAll("\\", "/"));
 	}
+	/** Cross-file value reads this extraction performed, with the digests read at parse time. */
+	exportReads = [];
+	/** @internal Set once by the parser after extraction, digests computed on warm caches. */
+	setExportReads(reads) {
+		this.exportReads = reads;
+	}
+	/** @internal The reads a consumer can verify instead of re-folding; see the Vite plugin. */
+	getExportReads() {
+		return this.exportReads;
+	}
 	/**
 	* Local source paths crossed while resolving values this extraction actually encoded.
 	*
@@ -1172,6 +1229,8 @@ function createParser(context) {
 			});
 		};
 		const recordDependency = (filePath) => parserResult.addDependency(filePath);
+		const exportReadPairs = /* @__PURE__ */ new Set();
+		const recordExportRead = (filePath, exportedName) => exportReadPairs.add(`${filePath.replaceAll("\\", "/")}\u0000${exportedName}`);
 		extract({
 			ast: sourceFile,
 			tokens: context.tokens ? {
@@ -1222,6 +1281,7 @@ function createParser(context) {
 			},
 			flags: { skipTraverseFiles: false },
 			recordDependency,
+			recordExportRead,
 			resolveModule
 		}).forEach((result, alias) => {
 			const name = file.getName(file.normalizeFnName(alias));
@@ -1314,6 +1374,19 @@ function createParser(context) {
 			});
 		});
 		parserResult.deadCalls = file.getDeadCalls();
+		if (exportReadPairs.size) {
+			const project = sourceFile.getProject();
+			parserResult.setExportReads([...exportReadPairs].map((pair) => {
+				const at = pair.indexOf("\0");
+				const file = pair.slice(0, at);
+				const name = pair.slice(at + 1);
+				return {
+					file,
+					name,
+					digest: digestExportValue(project.getSourceFile(file), name, resolveModule)
+				};
+			}));
+		}
 		return parserResult;
 	};
 }
@@ -1679,8 +1752,28 @@ var Project = class {
 	* dependency edge; now it would also leave a recipe permanently invisible to the module
 	* importing it, since resolution is what finds one.
 	*/
-	invalidate = (fileTreeChanged = true) => {
+	invalidate = (fileTreeChanged = true, changedPath) => {
 		this.#assertNotLoading();
+		/**
+		* A content edit to a file the project already holds invalidates *by path* rather than
+		* dropping every memoized value. Each cache entry records the module paths its
+		* computation read — the same record the watch system replays into fold dependencies —
+		* so marking the edited path stale rejects exactly the entries whose value could have
+		* moved, while a value resolved without reading this file keeps its cache. The edited
+		* file's own entries need no marking: its re-parse retires their key nodes.
+		*
+		* That narrowing holds only for content: a file appearing or disappearing can change
+		* what a specifier resolves to without any recorded path's bytes moving — extension
+		* precedence, a new local shadowing a package — so tree changes keep the full clear.
+		* The recipe-origin memo records no read-set, so it is cleared on every event either
+		* way; per edit that is one walk rebuilt lazily, not the per-transform storm the
+		* identical-text no-op in `addSourceFile` exists to prevent.
+		*/
+		if (!fileTreeChanged && changedPath) {
+			invalidateDependencyPath(this.normalizePath(changedPath));
+			clearImportedRecipeCache();
+			return;
+		}
 		invalidateResolutions();
 		if (fileTreeChanged) {
 			this.#moduleResolutionCache = void 0;
@@ -2233,7 +2326,7 @@ var Project = class {
 		if (existing && existing.getFullText() === content) return existing;
 		this.invalidateSourcePreparation(filePath, existing);
 		this.removedSourcePaths.delete(this.normalizePath(filePath));
-		this.invalidate(!existing);
+		this.invalidate(!existing, existing?.getFilePath());
 		return this.project.createSourceFile(filePath, content, {
 			overwrite: true,
 			scriptKind: scriptKindFor(filePath)
@@ -2252,11 +2345,22 @@ var Project = class {
 		}
 		return false;
 	};
+	/**
+	* The current digest of one exported value, for read verification.
+	*
+	* Same function and same resolver identity as the parse-time recording, which is what makes
+	* the comparison meaningful; see `digestExportValue`.
+	*/
+	digestExportRead = (filePath, exportedName, onCrossing) => {
+		this.#assertNotLoading();
+		this.#ensureSourceFiles();
+		return digestExportValue(this.getSourceFile(filePath), exportedName, this.resolveModule, onCrossing);
+	};
 	reloadSourceFile = (filePath) => {
 		this.#assertNotLoading();
 		this.#ensureSourceFiles();
-		this.invalidate(false);
 		const sourceFile = this.getSourceFile(filePath);
+		this.invalidate(false, sourceFile?.getFilePath());
 		if (!sourceFile) return;
 		this.invalidateSourcePreparation(filePath, sourceFile);
 		return sourceFile.refreshFromFileSystemSync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamboocss/parser",
-  "version": "1.46.0",
+  "version": "1.46.2",
   "description": "The static parser for bamboo css",
   "homepage": "https://bamboocss.com",
   "license": "MIT",
@@ -34,18 +34,18 @@
   "dependencies": {
     "ts-morph": "28.0.0",
     "ts-pattern": "5.9.0",
-    "@bamboocss/config": "^1.46.0",
-    "@bamboocss/core": "^1.46.0",
-    "@bamboocss/extractor": "1.46.0",
-    "@bamboocss/logger": "1.46.0",
-    "@bamboocss/shared": "1.46.0",
-    "@bamboocss/types": "1.46.0"
+    "@bamboocss/config": "^1.46.2",
+    "@bamboocss/core": "^1.46.2",
+    "@bamboocss/extractor": "1.46.2",
+    "@bamboocss/logger": "1.46.2",
+    "@bamboocss/shared": "1.46.2",
+    "@bamboocss/types": "1.46.2"
   },
   "devDependencies": {
     "@typescript/api": "npm:typescript@7.1.0-dev.20260819.1",
-    "@bamboocss/generator": "1.46.0",
-    "@bamboocss/plugin-svelte": "1.46.0",
-    "@bamboocss/plugin-vue": "1.46.0"
+    "@bamboocss/generator": "1.46.2",
+    "@bamboocss/plugin-svelte": "1.46.2",
+    "@bamboocss/plugin-vue": "1.46.2"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format=esm,cjs --dts",