@bamboocss/parser 1.12.3 → 1.13.1

package/LICENSE.md

@@ -1,6 +1,7 @@
 MIT License
 
 Copyright (c) 2023 Segun Adebayo
+Copyright (c) 2026 Gajus Kuizinas
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without limitation the

package/dist/index.cjs

@@ -690,7 +690,7 @@ function createParser(context) {
 				name = name.replace(".raw", "");
 				return { environment: Object.assign({}, defaultEnv, { extra: { [name]: { raw: (v) => v } } }) };
 			},
-			flags: { skipTraverseFiles: true }
+			flags: { skipTraverseFiles: false }
 		}).forEach((result, alias) => {
 			const name = file.getName(file.normalizeFnName(alias));
 			_bamboocss_logger.logger.debug(`ast:${name}`, name !== alias ? {
@@ -894,11 +894,110 @@ var Project = class {
 	get files() {
 		return this.options.getFiles();
 	}
+	/**
+	* Reverse dependency graph: imported file -> files importing it, both keyed on
+	* the source file's own normalized path so lookups match regardless of whether
+	* the caller passed a relative, aliased or platform-specific path.
+	*
+	* Populated while parsing. Cross-file extraction folds imported values into the
+	* importer's output, so editing a shared style file has to re-parse everyone who
+	* imports it — re-parsing only the changed file leaves consumers stale.
+	*/
+	dependents = /* @__PURE__ */ new Map();
+	/** Forward edges, so a re-parse can retract exactly the previous ones. */
+	dependencies = /* @__PURE__ */ new Map();
+	/**
+	* Path as a caller spells it -> the source file's own path.
+	*
+	* The graph is keyed on the latter, but callers pass whatever the watcher gave
+	* them. Resolving through the project covers that while the file is loaded;
+	* this keeps it resolvable afterwards too, so asking which files imported a
+	* *deleted* file still works and the unlink path does not depend on querying
+	* before removal.
+	*/
+	canonicalPaths = /* @__PURE__ */ new Map();
+	/**
+	* Files holding at least one import whose specifier resolved to nothing.
+	*
+	* A broken or not-yet-created import produces no edge, so when the file it wants
+	* finally appears there is nothing in the graph connecting them. These importers
+	* are the only candidates for that, and the set is normally empty.
+	*/
+	unresolvedImporters = /* @__PURE__ */ new Set();
+	/** Files whose imports did not all resolve when they were last parsed. */
+	getUnresolvedImporters = () => [...this.unresolvedImporters];
 	getSourceFile = (filePath) => {
 		return this.project.getSourceFile(filePath);
 	};
+	/** ts-morph reports forward slashes; normalize callers' paths to match on Windows. */
+	normalizePath = (filePath) => filePath.replaceAll("\\", "/");
+	/**
+	* Resolves a module specifier to a file already in the project.
+	*
+	* Deliberately not `decl.getModuleSpecifierSourceFile()`: that goes through the
+	* symbol table, which forces `initializeTypeChecker` on first use and costs
+	* hundreds of ms on a cold build. `ts.resolveModuleName` is purely a filesystem
+	* lookup, and a shared cache keeps repeat specifiers off the disk.
+	*
+	* Looks the result up rather than adding it, so resolving `react` cannot pull a
+	* `.d.ts` into the project. The graph only tracks files bamboo already scans.
+	*/
+	moduleResolutionCache;
+	resolveImport = (decl) => {
+		const moduleName = decl.getModuleSpecifierValue();
+		if (!moduleName) return;
+		const compilerOptions = this.project.getCompilerOptions();
+		this.moduleResolutionCache ??= ts_morph.ts.createModuleResolutionCache(this.project.getFileSystem().getCurrentDirectory(), (f) => f, compilerOptions);
+		const name = ts_morph.ts.resolveModuleName(moduleName, decl.getSourceFile().getFilePath(), compilerOptions, this.project.getModuleResolutionHost(), this.moduleResolutionCache).resolvedModule?.resolvedFileName;
+		return name ? this.project.getSourceFile(name) : void 0;
+	};
+	trackDependencies = (filePath, sourceFile) => {
+		const importer = this.normalizePath(sourceFile.getFilePath());
+		this.canonicalPaths.set(this.normalizePath(filePath), importer);
+		for (const previous of this.dependencies.get(importer) ?? []) this.dependents.get(previous)?.delete(importer);
+		const current = /* @__PURE__ */ new Set();
+		const declarations = [...sourceFile.getImportDeclarations(), ...sourceFile.getExportDeclarations()];
+		let unresolved = false;
+		for (const decl of declarations) {
+			const imported = this.resolveImport(decl);
+			if (!imported) {
+				if (decl.getModuleSpecifierValue()?.startsWith(".")) unresolved = true;
+				continue;
+			}
+			const importedPath = this.normalizePath(imported.getFilePath());
+			if (importedPath === importer) continue;
+			const importers = this.dependents.get(importedPath) ?? /* @__PURE__ */ new Set();
+			importers.add(importer);
+			this.dependents.set(importedPath, importers);
+			current.add(importedPath);
+		}
+		this.dependencies.set(importer, current);
+		if (unresolved) this.unresolvedImporters.add(importer);
+		else this.unresolvedImporters.delete(importer);
+	};
+	/**
+	* Every file that transitively imports `filePath`, so a watcher can re-parse the
+	* consumers of an edited file. Excludes `filePath` itself.
+	*/
+	getDependents = (filePath) => {
+		const given = this.normalizePath(filePath);
+		const resolved = this.project.getSourceFile(filePath)?.getFilePath();
+		const start = resolved ? this.normalizePath(resolved) : this.canonicalPaths.get(given) ?? given;
+		const seen = /* @__PURE__ */ new Set();
+		const queue = [start];
+		while (queue.length) {
+			const current = queue.shift();
+			for (const importer of this.dependents.get(current) ?? []) {
+				if (importer === start || seen.has(importer)) continue;
+				seen.add(importer);
+				queue.push(importer);
+			}
+		}
+		return [...seen];
+	};
 	createSourceFile = (filePath) => {
 		const { readFile } = this.options;
+		(0, _bamboocss_extractor.clearBoxNodeCache)();
 		return this.project.createSourceFile(filePath, readFile(filePath), {
 			overwrite: true,
 			scriptKind: ts_morph.ScriptKind.TSX
@@ -909,6 +1008,7 @@ var Project = class {
 		for (const file of files) this.createSourceFile(file);
 	};
 	addSourceFile = (filePath, content) => {
+		(0, _bamboocss_extractor.clearBoxNodeCache)();
 		return this.project.createSourceFile(filePath, content, {
 			overwrite: true,
 			scriptKind: ts_morph.ScriptKind.TSX
@@ -916,14 +1016,19 @@ var Project = class {
 	};
 	removeSourceFile = (filePath) => {
 		const sourceFile = this.project.getSourceFile(filePath);
-		if (sourceFile) return this.project.removeSourceFile(sourceFile);
+		if (sourceFile) {
+			(0, _bamboocss_extractor.clearBoxNodeCache)();
+			return this.project.removeSourceFile(sourceFile);
+		}
 		return false;
 	};
 	reloadSourceFile = (filePath) => {
+		(0, _bamboocss_extractor.clearBoxNodeCache)();
 		return this.getSourceFile(filePath)?.refreshFromFileSystemSync();
 	};
 	reloadSourceFiles = () => {
 		const files = this.getFiles();
+		(0, _bamboocss_extractor.clearBoxNodeCache)();
 		for (const file of files) this.getSourceFile(file)?.refreshFromFileSystemSync() ?? this.project.addSourceFileAtPath(file);
 	};
 	get readFile() {
@@ -943,6 +1048,7 @@ var Project = class {
 		if (filePath.endsWith(".json")) return this.parseJson(filePath);
 		const sourceFile = this.project.getSourceFile(filePath);
 		if (!sourceFile) return;
+		this.trackDependencies(filePath, sourceFile);
 		const original = sourceFile.getText();
 		const options = {};
 		const transformed = hooks["parser:before"]?.({

package/dist/index.d.cts

@@ -31,6 +31,67 @@ declare class Generator extends Context {
   appendLayerParams: (sheet: Stylesheet) => void;
   appendBaselineCss: (sheet: Stylesheet) => void;
   appendParserCss: (sheet: Stylesheet) => void;
+  /**
+   * Drop token css variables nothing can reach. Call this only once the sheet holds the
+   * whole stylesheet — a baseline-only sheet has no utilities to reference anything, so
+   * every token would look unused.
+   *
+   * `keep` carries references this cannot see for itself; see `collectTokenReferences`.
+   */
+  pruneTokens: (sheet: Stylesheet, keep?: Set<string>) => {
+    removed: number;
+    kept: number;
+  } | undefined;
+  /**
+   * Drop `@keyframes` nothing can reach. Same completeness requirement as
+   * `pruneTokens`: the sheet has to hold the whole stylesheet, or every keyframe looks
+   * unused for want of a utility to reference it.
+   *
+   * `keep` carries names this cannot see for itself; see `collectKeyframeReferences`.
+   */
+  pruneKeyframes: (sheet: Stylesheet, keep?: Set<string>) => {
+    removed: number;
+    kept: number;
+  } | undefined;
+  /**
+   * Keyframes the themes name.
+   *
+   * A theme is emitted as its own artifact and injected at runtime, so its css is not in
+   * the sheet being pruned. A theme that points an animation token at a different
+   * keyframe than the base does — `--animations-enter: fade-in` in the base and
+   * `slide-up` under `dark` — would otherwise have that keyframe removed, because
+   * nothing in the pruned sheet ever names it.
+   */
+  private getThemeKeyframeNames;
+  /**
+   * Every custom property the token system declares. Used as the allow-list of what may
+   * be removed, so custom properties from `globalCss` are never touched.
+   */
+  private getTokenVarNames;
+  /**
+   * Everything the themes refer to.
+   *
+   * A theme is emitted as its own artifact and injected at runtime, so its css is not in
+   * the sheet being pruned and nothing there points at what it needs. A theme that maps a
+   * token onto a base colour would otherwise be left referring to a declaration that has
+   * been removed.
+   */
+  private getThemeTokenVars;
+  /**
+   * Tokens whose javascript value is a `var()` reference rather than a literal.
+   * `token('colors.text')` hands those to the caller as a reference, so the declaration
+   * has to survive whether or not the generated css mentions it. Ordinary tokens resolve
+   * to a literal in javascript and need no such exemption.
+   *
+   * The two cases mirror `generateTokenJs`, which is what decides the value javascript
+   * actually receives:
+   *
+   * - A virtual token, or one carrying a condition, is handed its own `varRef`.
+   * - A negative token is handed `calc(var(--x) * -1)`, so it is a reference too — but to
+   *   the *positive* token's declaration. Its own var is never declared, so the name has
+   *   to come out of the value.
+   */
+  private getAlwaysKeptTokenVars;
   getParserCss: (decoder: StyleDecoder) => string;
   getCss: (stylesheet?: Stylesheet) => string;
   /**
@@ -119,7 +180,60 @@ declare class Project {
   get parserOptions(): ParserOptions;
   constructor(options: ProjectOptions);
   get files(): string[];
+  /**
+   * Reverse dependency graph: imported file -> files importing it, both keyed on
+   * the source file's own normalized path so lookups match regardless of whether
+   * the caller passed a relative, aliased or platform-specific path.
+   *
+   * Populated while parsing. Cross-file extraction folds imported values into the
+   * importer's output, so editing a shared style file has to re-parse everyone who
+   * imports it — re-parsing only the changed file leaves consumers stale.
+   */
+  private dependents;
+  /** Forward edges, so a re-parse can retract exactly the previous ones. */
+  private dependencies;
+  /**
+   * Path as a caller spells it -> the source file's own path.
+   *
+   * The graph is keyed on the latter, but callers pass whatever the watcher gave
+   * them. Resolving through the project covers that while the file is loaded;
+   * this keeps it resolvable afterwards too, so asking which files imported a
+   * *deleted* file still works and the unlink path does not depend on querying
+   * before removal.
+   */
+  private canonicalPaths;
+  /**
+   * Files holding at least one import whose specifier resolved to nothing.
+   *
+   * A broken or not-yet-created import produces no edge, so when the file it wants
+   * finally appears there is nothing in the graph connecting them. These importers
+   * are the only candidates for that, and the set is normally empty.
+   */
+  private unresolvedImporters;
+  /** Files whose imports did not all resolve when they were last parsed. */
+  getUnresolvedImporters: () => string[];
   getSourceFile: (filePath: string) => SourceFile | undefined;
+  /** ts-morph reports forward slashes; normalize callers' paths to match on Windows. */
+  private normalizePath;
+  /**
+   * Resolves a module specifier to a file already in the project.
+   *
+   * Deliberately not `decl.getModuleSpecifierSourceFile()`: that goes through the
+   * symbol table, which forces `initializeTypeChecker` on first use and costs
+   * hundreds of ms on a cold build. `ts.resolveModuleName` is purely a filesystem
+   * lookup, and a shared cache keeps repeat specifiers off the disk.
+   *
+   * Looks the result up rather than adding it, so resolving `react` cannot pull a
+   * `.d.ts` into the project. The graph only tracks files bamboo already scans.
+   */
+  private moduleResolutionCache;
+  private resolveImport;
+  private trackDependencies;
+  /**
+   * Every file that transitively imports `filePath`, so a watcher can re-parse the
+   * consumers of an edited file. Excludes `filePath` itself.
+   */
+  getDependents: (filePath: string) => string[];
   createSourceFile: (filePath: string) => SourceFile;
   createSourceFiles: () => void;
   addSourceFile: (filePath: string, content: string) => SourceFile;

package/dist/index.d.mts

@@ -31,6 +31,67 @@ declare class Generator extends Context {
   appendLayerParams: (sheet: Stylesheet) => void;
   appendBaselineCss: (sheet: Stylesheet) => void;
   appendParserCss: (sheet: Stylesheet) => void;
+  /**
+   * Drop token css variables nothing can reach. Call this only once the sheet holds the
+   * whole stylesheet — a baseline-only sheet has no utilities to reference anything, so
+   * every token would look unused.
+   *
+   * `keep` carries references this cannot see for itself; see `collectTokenReferences`.
+   */
+  pruneTokens: (sheet: Stylesheet, keep?: Set<string>) => {
+    removed: number;
+    kept: number;
+  } | undefined;
+  /**
+   * Drop `@keyframes` nothing can reach. Same completeness requirement as
+   * `pruneTokens`: the sheet has to hold the whole stylesheet, or every keyframe looks
+   * unused for want of a utility to reference it.
+   *
+   * `keep` carries names this cannot see for itself; see `collectKeyframeReferences`.
+   */
+  pruneKeyframes: (sheet: Stylesheet, keep?: Set<string>) => {
+    removed: number;
+    kept: number;
+  } | undefined;
+  /**
+   * Keyframes the themes name.
+   *
+   * A theme is emitted as its own artifact and injected at runtime, so its css is not in
+   * the sheet being pruned. A theme that points an animation token at a different
+   * keyframe than the base does — `--animations-enter: fade-in` in the base and
+   * `slide-up` under `dark` — would otherwise have that keyframe removed, because
+   * nothing in the pruned sheet ever names it.
+   */
+  private getThemeKeyframeNames;
+  /**
+   * Every custom property the token system declares. Used as the allow-list of what may
+   * be removed, so custom properties from `globalCss` are never touched.
+   */
+  private getTokenVarNames;
+  /**
+   * Everything the themes refer to.
+   *
+   * A theme is emitted as its own artifact and injected at runtime, so its css is not in
+   * the sheet being pruned and nothing there points at what it needs. A theme that maps a
+   * token onto a base colour would otherwise be left referring to a declaration that has
+   * been removed.
+   */
+  private getThemeTokenVars;
+  /**
+   * Tokens whose javascript value is a `var()` reference rather than a literal.
+   * `token('colors.text')` hands those to the caller as a reference, so the declaration
+   * has to survive whether or not the generated css mentions it. Ordinary tokens resolve
+   * to a literal in javascript and need no such exemption.
+   *
+   * The two cases mirror `generateTokenJs`, which is what decides the value javascript
+   * actually receives:
+   *
+   * - A virtual token, or one carrying a condition, is handed its own `varRef`.
+   * - A negative token is handed `calc(var(--x) * -1)`, so it is a reference too — but to
+   *   the *positive* token's declaration. Its own var is never declared, so the name has
+   *   to come out of the value.
+   */
+  private getAlwaysKeptTokenVars;
   getParserCss: (decoder: StyleDecoder) => string;
   getCss: (stylesheet?: Stylesheet) => string;
   /**
@@ -119,7 +180,60 @@ declare class Project {
   get parserOptions(): ParserOptions;
   constructor(options: ProjectOptions);
   get files(): string[];
+  /**
+   * Reverse dependency graph: imported file -> files importing it, both keyed on
+   * the source file's own normalized path so lookups match regardless of whether
+   * the caller passed a relative, aliased or platform-specific path.
+   *
+   * Populated while parsing. Cross-file extraction folds imported values into the
+   * importer's output, so editing a shared style file has to re-parse everyone who
+   * imports it — re-parsing only the changed file leaves consumers stale.
+   */
+  private dependents;
+  /** Forward edges, so a re-parse can retract exactly the previous ones. */
+  private dependencies;
+  /**
+   * Path as a caller spells it -> the source file's own path.
+   *
+   * The graph is keyed on the latter, but callers pass whatever the watcher gave
+   * them. Resolving through the project covers that while the file is loaded;
+   * this keeps it resolvable afterwards too, so asking which files imported a
+   * *deleted* file still works and the unlink path does not depend on querying
+   * before removal.
+   */
+  private canonicalPaths;
+  /**
+   * Files holding at least one import whose specifier resolved to nothing.
+   *
+   * A broken or not-yet-created import produces no edge, so when the file it wants
+   * finally appears there is nothing in the graph connecting them. These importers
+   * are the only candidates for that, and the set is normally empty.
+   */
+  private unresolvedImporters;
+  /** Files whose imports did not all resolve when they were last parsed. */
+  getUnresolvedImporters: () => string[];
   getSourceFile: (filePath: string) => SourceFile | undefined;
+  /** ts-morph reports forward slashes; normalize callers' paths to match on Windows. */
+  private normalizePath;
+  /**
+   * Resolves a module specifier to a file already in the project.
+   *
+   * Deliberately not `decl.getModuleSpecifierSourceFile()`: that goes through the
+   * symbol table, which forces `initializeTypeChecker` on first use and costs
+   * hundreds of ms on a cold build. `ts.resolveModuleName` is purely a filesystem
+   * lookup, and a shared cache keeps repeat specifiers off the disk.
+   *
+   * Looks the result up rather than adding it, so resolving `react` cannot pull a
+   * `.d.ts` into the project. The graph only tracks files bamboo already scans.
+   */
+  private moduleResolutionCache;
+  private resolveImport;
+  private trackDependencies;
+  /**
+   * Every file that transitively imports `filePath`, so a watcher can re-parse the
+   * consumers of an edited file. Excludes `filePath` itself.
+   */
+  getDependents: (filePath: string) => string[];
   createSourceFile: (filePath: string) => SourceFile;
   createSourceFiles: () => void;
   addSourceFile: (filePath: string, content: string) => SourceFile;

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { Node, Project as Project$1, ScriptKind, ts } from "ts-morph";
-import { box, extract, unbox } from "@bamboocss/extractor";
+import { box, clearBoxNodeCache, extract, unbox } from "@bamboocss/extractor";
 import { BambooError, astish, compact, getOrCreateSet, patternFns } from "@bamboocss/shared";
 import { logger } from "@bamboocss/logger";
 import { match } from "ts-pattern";
@@ -689,7 +689,7 @@ function createParser(context) {
 				name = name.replace(".raw", "");
 				return { environment: Object.assign({}, defaultEnv, { extra: { [name]: { raw: (v) => v } } }) };
 			},
-			flags: { skipTraverseFiles: true }
+			flags: { skipTraverseFiles: false }
 		}).forEach((result, alias) => {
 			const name = file.getName(file.normalizeFnName(alias));
 			logger.debug(`ast:${name}`, name !== alias ? {
@@ -893,11 +893,110 @@ var Project = class {
 	get files() {
 		return this.options.getFiles();
 	}
+	/**
+	* Reverse dependency graph: imported file -> files importing it, both keyed on
+	* the source file's own normalized path so lookups match regardless of whether
+	* the caller passed a relative, aliased or platform-specific path.
+	*
+	* Populated while parsing. Cross-file extraction folds imported values into the
+	* importer's output, so editing a shared style file has to re-parse everyone who
+	* imports it — re-parsing only the changed file leaves consumers stale.
+	*/
+	dependents = /* @__PURE__ */ new Map();
+	/** Forward edges, so a re-parse can retract exactly the previous ones. */
+	dependencies = /* @__PURE__ */ new Map();
+	/**
+	* Path as a caller spells it -> the source file's own path.
+	*
+	* The graph is keyed on the latter, but callers pass whatever the watcher gave
+	* them. Resolving through the project covers that while the file is loaded;
+	* this keeps it resolvable afterwards too, so asking which files imported a
+	* *deleted* file still works and the unlink path does not depend on querying
+	* before removal.
+	*/
+	canonicalPaths = /* @__PURE__ */ new Map();
+	/**
+	* Files holding at least one import whose specifier resolved to nothing.
+	*
+	* A broken or not-yet-created import produces no edge, so when the file it wants
+	* finally appears there is nothing in the graph connecting them. These importers
+	* are the only candidates for that, and the set is normally empty.
+	*/
+	unresolvedImporters = /* @__PURE__ */ new Set();
+	/** Files whose imports did not all resolve when they were last parsed. */
+	getUnresolvedImporters = () => [...this.unresolvedImporters];
 	getSourceFile = (filePath) => {
 		return this.project.getSourceFile(filePath);
 	};
+	/** ts-morph reports forward slashes; normalize callers' paths to match on Windows. */
+	normalizePath = (filePath) => filePath.replaceAll("\\", "/");
+	/**
+	* Resolves a module specifier to a file already in the project.
+	*
+	* Deliberately not `decl.getModuleSpecifierSourceFile()`: that goes through the
+	* symbol table, which forces `initializeTypeChecker` on first use and costs
+	* hundreds of ms on a cold build. `ts.resolveModuleName` is purely a filesystem
+	* lookup, and a shared cache keeps repeat specifiers off the disk.
+	*
+	* Looks the result up rather than adding it, so resolving `react` cannot pull a
+	* `.d.ts` into the project. The graph only tracks files bamboo already scans.
+	*/
+	moduleResolutionCache;
+	resolveImport = (decl) => {
+		const moduleName = decl.getModuleSpecifierValue();
+		if (!moduleName) return;
+		const compilerOptions = this.project.getCompilerOptions();
+		this.moduleResolutionCache ??= ts.createModuleResolutionCache(this.project.getFileSystem().getCurrentDirectory(), (f) => f, compilerOptions);
+		const name = ts.resolveModuleName(moduleName, decl.getSourceFile().getFilePath(), compilerOptions, this.project.getModuleResolutionHost(), this.moduleResolutionCache).resolvedModule?.resolvedFileName;
+		return name ? this.project.getSourceFile(name) : void 0;
+	};
+	trackDependencies = (filePath, sourceFile) => {
+		const importer = this.normalizePath(sourceFile.getFilePath());
+		this.canonicalPaths.set(this.normalizePath(filePath), importer);
+		for (const previous of this.dependencies.get(importer) ?? []) this.dependents.get(previous)?.delete(importer);
+		const current = /* @__PURE__ */ new Set();
+		const declarations = [...sourceFile.getImportDeclarations(), ...sourceFile.getExportDeclarations()];
+		let unresolved = false;
+		for (const decl of declarations) {
+			const imported = this.resolveImport(decl);
+			if (!imported) {
+				if (decl.getModuleSpecifierValue()?.startsWith(".")) unresolved = true;
+				continue;
+			}
+			const importedPath = this.normalizePath(imported.getFilePath());
+			if (importedPath === importer) continue;
+			const importers = this.dependents.get(importedPath) ?? /* @__PURE__ */ new Set();
+			importers.add(importer);
+			this.dependents.set(importedPath, importers);
+			current.add(importedPath);
+		}
+		this.dependencies.set(importer, current);
+		if (unresolved) this.unresolvedImporters.add(importer);
+		else this.unresolvedImporters.delete(importer);
+	};
+	/**
+	* Every file that transitively imports `filePath`, so a watcher can re-parse the
+	* consumers of an edited file. Excludes `filePath` itself.
+	*/
+	getDependents = (filePath) => {
+		const given = this.normalizePath(filePath);
+		const resolved = this.project.getSourceFile(filePath)?.getFilePath();
+		const start = resolved ? this.normalizePath(resolved) : this.canonicalPaths.get(given) ?? given;
+		const seen = /* @__PURE__ */ new Set();
+		const queue = [start];
+		while (queue.length) {
+			const current = queue.shift();
+			for (const importer of this.dependents.get(current) ?? []) {
+				if (importer === start || seen.has(importer)) continue;
+				seen.add(importer);
+				queue.push(importer);
+			}
+		}
+		return [...seen];
+	};
 	createSourceFile = (filePath) => {
 		const { readFile } = this.options;
+		clearBoxNodeCache();
 		return this.project.createSourceFile(filePath, readFile(filePath), {
 			overwrite: true,
 			scriptKind: ScriptKind.TSX
@@ -908,6 +1007,7 @@ var Project = class {
 		for (const file of files) this.createSourceFile(file);
 	};
 	addSourceFile = (filePath, content) => {
+		clearBoxNodeCache();
 		return this.project.createSourceFile(filePath, content, {
 			overwrite: true,
 			scriptKind: ScriptKind.TSX
@@ -915,14 +1015,19 @@ var Project = class {
 	};
 	removeSourceFile = (filePath) => {
 		const sourceFile = this.project.getSourceFile(filePath);
-		if (sourceFile) return this.project.removeSourceFile(sourceFile);
+		if (sourceFile) {
+			clearBoxNodeCache();
+			return this.project.removeSourceFile(sourceFile);
+		}
 		return false;
 	};
 	reloadSourceFile = (filePath) => {
+		clearBoxNodeCache();
 		return this.getSourceFile(filePath)?.refreshFromFileSystemSync();
 	};
 	reloadSourceFiles = () => {
 		const files = this.getFiles();
+		clearBoxNodeCache();
 		for (const file of files) this.getSourceFile(file)?.refreshFromFileSystemSync() ?? this.project.addSourceFileAtPath(file);
 	};
 	get readFile() {
@@ -942,6 +1047,7 @@ var Project = class {
 		if (filePath.endsWith(".json")) return this.parseJson(filePath);
 		const sourceFile = this.project.getSourceFile(filePath);
 		if (!sourceFile) return;
+		this.trackDependencies(filePath, sourceFile);
 		const original = sourceFile.getText();
 		const options = {};
 		const transformed = hooks["parser:before"]?.({

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@bamboocss/parser",
-  "version": "1.12.3",
+  "version": "1.13.1",
   "description": "The static parser for bamboo css",
-  "homepage": "https://bamboo-css.com",
+  "homepage": "https://bamboocss.com",
   "license": "MIT",
-  "author": "Segun Adebayo <joseshegs@gmail.com>",
+  "author": "Gajus Kuizinas <gajus@gajus.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bamboocss/bamboo.git",
@@ -34,17 +34,17 @@
   "dependencies": {
     "ts-morph": "28.0.0",
     "ts-pattern": "5.9.0",
-    "@bamboocss/config": "^1.12.3",
-    "@bamboocss/extractor": "1.12.3",
-    "@bamboocss/core": "^1.12.3",
-    "@bamboocss/shared": "1.12.3",
-    "@bamboocss/types": "1.12.3",
-    "@bamboocss/logger": "1.12.3"
+    "@bamboocss/config": "^1.13.1",
+    "@bamboocss/core": "^1.13.1",
+    "@bamboocss/extractor": "1.13.1",
+    "@bamboocss/logger": "1.13.1",
+    "@bamboocss/shared": "1.13.1",
+    "@bamboocss/types": "1.13.1"
   },
   "devDependencies": {
-    "@bamboocss/plugin-svelte": "1.12.3",
-    "@bamboocss/plugin-vue": "1.12.3",
-    "@bamboocss/generator": "1.12.3"
+    "@bamboocss/generator": "1.13.1",
+    "@bamboocss/plugin-svelte": "1.13.1",
+    "@bamboocss/plugin-vue": "1.13.1"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format=esm,cjs --dts",