@bamboocss/extractor 1.17.1 → 1.17.3

package/dist/index.cjs

@@ -306,76 +306,169 @@ const box = {
 	}
 };
 //#endregion
-//#region src/evaluate-node.ts
-const TsEvalError = Symbol("EvalError");
-const cacheMap$2 = /* @__PURE__ */ new WeakMap();
+//#region src/resolve-imported-value.ts
+/**
+* The values an expression borrows from other modules, resolved by reading the imports.
+*
+* A call to a helper in a neighbouring file has to resolve, or its declarations are silently
+* absent from the stylesheet — and for a recipe that is not a partial loss but a different
+* hash and an element with no styles at all.
+*
+* The evaluator can be handed a TypeScript type checker to follow the import itself, and was
+* for a while. That is far more than the job needs: asking for one symbol makes TypeScript
+* bind and check the whole program, every reachable `.d.ts` included. Measured on a 400-file
+* project it cost **+38% CPU and +30% peak RSS**, and because the expense is the checker
+* existing rather than how often it is consulted, it grows with the size of the codebase
+* rather than with the number of style calls — a large project reported a 5.4x extraction
+* slowdown and an OOM in CI.
+*
+* Following an import is two cheap steps this package already had: resolve the specifier to
+* a file (`ts.resolveModuleName`, path lookup, no checker), then read that file's exported
+* declaration. Crossing the import boundary is the only thing the checker was doing here.
+*
+* The evaluator resolves everything *within* a module by walking scopes, so a helper that
+* refers to another binding in its own file needs nothing from us.
+*/
+/** How far a chain of helpers importing helpers is followed. */
+const MAX_DEPTH = 4;
+/** Evaluated once per declaration, however many call sites reach it. */
+const evaluatedValues = /* @__PURE__ */ new WeakMap();
 /**
-* Whether a call reaches a function declared outside this project.
+* Local name to the name and declaration it was imported from.
 *
-* Passing a type checker lets the evaluator resolve an identifier to its declaration in
-* another module, which is what makes a call to an imported helper resolvable at all — a
-* style helper in a neighbouring file used to come back unresolvable, and for a recipe that
-* is not a partial loss but a different config, a different hash, and an element with no
-* styles.
+* Deliberately not cached per file. The nodes are invalidated whenever a file is reloaded —
+* a watch rebuild does exactly that — and a cache holding them hands back nodes ts-morph has
+* forgotten, which throws rather than merely going stale. Rebuilding is a syntactic walk of
+* the import statements, and it only happens for an expression that already failed to
+* evaluate, so it is not on the ordinary path.
+*/
+const importBindingsFor = (sourceFile) => {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		for (const specifier of declaration.getNamedImports()) {
+			const local = (specifier.getAliasNode() ?? specifier.getNameNode()).getText();
+			bindings.set(local, {
+				declaration,
+				exportedName: specifier.getNameNode().getText()
+			});
+		}
+		const defaultImport = declaration.getDefaultImport();
+		if (defaultImport) bindings.set(defaultImport.getText(), {
+			declaration,
+			exportedName: "default"
+		});
+	}
+	return bindings;
+};
+/** What an imported name refers to, or nothing if it cannot be reached safely. */
+const valueForBinding = (binding, ctx, stack, depth, evaluateExpression) => {
+	const sourceFile = getModuleSpecifierSourceFile(binding.declaration);
+	if (!sourceFile) return;
+	if (sourceFile.isInNodeModules()) return;
+	const declaration = getExportedVarDeclarationWithName(binding.exportedName, sourceFile, stack, ctx);
+	if (!declaration) return;
+	if (evaluatedValues.has(declaration)) return { value: evaluatedValues.get(declaration) };
+	const initializer = declaration.getInitializer();
+	if (!initializer) return;
+	const value = evaluateExpression(initializer, stack, ctx, depth + 1);
+	if (value === void 0) return;
+	evaluatedValues.set(declaration, value);
+	return { value };
+};
+/**
+* Bindings for the names this expression takes from other modules, or nothing if it takes
+* none that can be reached.
 *
-* It also means evaluating whatever it resolves to, so the project boundary is where that
-* stops. A dependency's code is not ours to run at build time, however pure it looks, and
-* declining leaves exactly the behaviour that shipped before the checker was passed.
+* Called only after an evaluation has already failed. Everything that resolves today does so
+* without this, and an expression that reaches an unresolvable import used to be dropped
+* outright — so nothing that works pays for it, and nothing that pays for it was working.
 */
-const resolvesWithinProject = (node) => {
-	if (!ts_morph.Node.isCallExpression(node)) return false;
-	const symbol = node.getExpression().getSymbol();
-	if (!symbol) return false;
-	const declarations = (symbol.getAliasedSymbol() ?? symbol).getDeclarations();
-	if (!declarations.length) return false;
-	return !declarations.some((declaration) => declaration.getSourceFile().isInNodeModules());
+const importedEnvironmentFor = (node, ctx, stack, depth, evaluateExpression) => {
+	if (depth >= MAX_DEPTH) return;
+	const calls = node.getDescendantsOfKind(ts_morph.SyntaxKind.CallExpression);
+	if (ts_morph.Node.isCallExpression(node)) calls.unshift(node);
+	if (!calls.length) return;
+	const bindings = importBindingsFor(node.getSourceFile());
+	if (!bindings.size) return;
+	let environment;
+	for (const call of calls) {
+		const callee = call.getExpression();
+		const binding = bindings.get(callee.getText());
+		if (!binding || environment?.[callee.getText()] !== void 0) continue;
+		const resolved = valueForBinding(binding, ctx, stack, depth, evaluateExpression);
+		if (!resolved) continue;
+		environment ??= {};
+		environment[callee.getText()] = resolved.value;
+	}
+	return environment;
 };
-/** One per project. `getTypeChecker()` is cheap, but this runs per evaluated call. */
-const typeCheckers = /* @__PURE__ */ new WeakMap();
-const typeCheckerFor = (node) => {
-	const project = node.getProject();
-	let checker = typeCheckers.get(project);
-	if (!checker) {
-		checker = project.getTypeChecker().compilerObject;
-		typeCheckers.set(project, checker);
+//#endregion
+//#region src/evaluate-node.ts
+const TsEvalError = Symbol("EvalError");
+const cacheMap$2 = /* @__PURE__ */ new WeakMap();
+/** @see https://github.com/wessberg/ts-evaluator#setting-up-policies */
+const POLICY = {
+	console: false,
+	deterministic: true,
+	io: {
+		read: true,
+		write: false
+	},
+	maxOpDuration: 1e3,
+	maxOps: Number.POSITIVE_INFINITY,
+	network: false,
+	process: {
+		exit: false,
+		spawnChild: false
 	}
-	return checker;
 };
 /**
-* Evaluates a node with strict policies restrictions
-* @see https://github.com/wessberg/ts-evaluator#setting-up-policies
+* Evaluates a node with strict policy restrictions.
+*
+* No type checker is passed. The evaluator accepts one, and it is the obvious way to let a
+* call reach a helper in another module — but asking TypeScript for a single symbol makes it
+* bind and check the entire program, `.d.ts` files included. That cost is paid by every
+* project on every build, scales with the size of the codebase rather than with the number
+* of style calls, and does not show up in a benchmark small enough to have no program to
+* check. See `resolve-imported-value.ts`, which crosses the import boundary directly for the
+* few expressions that need it.
 */
-const evaluateNode = (node, stack, ctx) => {
+const evaluateNode = (node, stack, ctx, depth = 0) => {
 	if (ctx.flags?.skipEvaluate) return;
 	if (ctx.canEval && !ctx.canEval?.(node, stack)) return;
-	if (cacheMap$2.has(node)) return cacheMap$2.get(node);
-	const result = (0, ts_evaluator.evaluate)({
-		...resolvesWithinProject(node) ? { typeChecker: typeCheckerFor(node) } : {},
-		policy: {
-			deterministic: true,
-			network: false,
-			console: false,
-			maxOps: Number.POSITIVE_INFINITY,
-			maxOpDuration: 1e3,
-			io: {
-				read: true,
-				write: false
-			},
-			process: {
-				exit: false,
-				spawnChild: false
-			}
-		},
+	if (depth === 0 && cacheMap$2.has(node)) return cacheMap$2.get(node);
+	const options = {
+		policy: { ...POLICY },
 		...ctx.getEvaluateOptions?.(node, stack),
 		node: node.compilerNode,
 		typescript: ts_morph.ts
-	});
+	};
+	let result = (0, ts_evaluator.evaluate)(options);
+	/**
+	* Retried only on failure, with whatever this expression imports put in scope.
+	*
+	* The order matters for cost. Everything that resolves today does so on the first attempt,
+	* so no working call pays anything for this — and an expression that reaches an
+	* unresolvable import was dropped outright before, so nothing that pays for it was
+	* working. Resolving imports up front instead would put a walk of every style object on
+	* the path of every build.
+	*/
+	if (!result.success) {
+		const imported = importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode);
+		if (imported) result = (0, ts_evaluator.evaluate)({
+			...options,
+			environment: {
+				...options.environment,
+				extra: imported
+			}
+		});
+	}
 	const expr = result.success ? result.value : TsEvalError;
-	cacheMap$2.set(node, expr);
+	if (depth === 0) cacheMap$2.set(node, expr);
 	return expr;
 };
-const safeEvaluateNode = (node, stack, ctx) => {
-	const result = evaluateNode(node, stack, ctx);
+const safeEvaluateNode = (node, stack, ctx, depth = 0) => {
+	const result = evaluateNode(node, stack, ctx, depth);
 	if (result === TsEvalError) return;
 	return result;
 };

package/dist/index.mjs

@@ -305,76 +305,169 @@ const box = {
 	}
 };
 //#endregion
-//#region src/evaluate-node.ts
-const TsEvalError = Symbol("EvalError");
-const cacheMap$2 = /* @__PURE__ */ new WeakMap();
+//#region src/resolve-imported-value.ts
+/**
+* The values an expression borrows from other modules, resolved by reading the imports.
+*
+* A call to a helper in a neighbouring file has to resolve, or its declarations are silently
+* absent from the stylesheet — and for a recipe that is not a partial loss but a different
+* hash and an element with no styles at all.
+*
+* The evaluator can be handed a TypeScript type checker to follow the import itself, and was
+* for a while. That is far more than the job needs: asking for one symbol makes TypeScript
+* bind and check the whole program, every reachable `.d.ts` included. Measured on a 400-file
+* project it cost **+38% CPU and +30% peak RSS**, and because the expense is the checker
+* existing rather than how often it is consulted, it grows with the size of the codebase
+* rather than with the number of style calls — a large project reported a 5.4x extraction
+* slowdown and an OOM in CI.
+*
+* Following an import is two cheap steps this package already had: resolve the specifier to
+* a file (`ts.resolveModuleName`, path lookup, no checker), then read that file's exported
+* declaration. Crossing the import boundary is the only thing the checker was doing here.
+*
+* The evaluator resolves everything *within* a module by walking scopes, so a helper that
+* refers to another binding in its own file needs nothing from us.
+*/
+/** How far a chain of helpers importing helpers is followed. */
+const MAX_DEPTH = 4;
+/** Evaluated once per declaration, however many call sites reach it. */
+const evaluatedValues = /* @__PURE__ */ new WeakMap();
 /**
-* Whether a call reaches a function declared outside this project.
+* Local name to the name and declaration it was imported from.
 *
-* Passing a type checker lets the evaluator resolve an identifier to its declaration in
-* another module, which is what makes a call to an imported helper resolvable at all — a
-* style helper in a neighbouring file used to come back unresolvable, and for a recipe that
-* is not a partial loss but a different config, a different hash, and an element with no
-* styles.
+* Deliberately not cached per file. The nodes are invalidated whenever a file is reloaded —
+* a watch rebuild does exactly that — and a cache holding them hands back nodes ts-morph has
+* forgotten, which throws rather than merely going stale. Rebuilding is a syntactic walk of
+* the import statements, and it only happens for an expression that already failed to
+* evaluate, so it is not on the ordinary path.
+*/
+const importBindingsFor = (sourceFile) => {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const declaration of sourceFile.getImportDeclarations()) {
+		for (const specifier of declaration.getNamedImports()) {
+			const local = (specifier.getAliasNode() ?? specifier.getNameNode()).getText();
+			bindings.set(local, {
+				declaration,
+				exportedName: specifier.getNameNode().getText()
+			});
+		}
+		const defaultImport = declaration.getDefaultImport();
+		if (defaultImport) bindings.set(defaultImport.getText(), {
+			declaration,
+			exportedName: "default"
+		});
+	}
+	return bindings;
+};
+/** What an imported name refers to, or nothing if it cannot be reached safely. */
+const valueForBinding = (binding, ctx, stack, depth, evaluateExpression) => {
+	const sourceFile = getModuleSpecifierSourceFile(binding.declaration);
+	if (!sourceFile) return;
+	if (sourceFile.isInNodeModules()) return;
+	const declaration = getExportedVarDeclarationWithName(binding.exportedName, sourceFile, stack, ctx);
+	if (!declaration) return;
+	if (evaluatedValues.has(declaration)) return { value: evaluatedValues.get(declaration) };
+	const initializer = declaration.getInitializer();
+	if (!initializer) return;
+	const value = evaluateExpression(initializer, stack, ctx, depth + 1);
+	if (value === void 0) return;
+	evaluatedValues.set(declaration, value);
+	return { value };
+};
+/**
+* Bindings for the names this expression takes from other modules, or nothing if it takes
+* none that can be reached.
 *
-* It also means evaluating whatever it resolves to, so the project boundary is where that
-* stops. A dependency's code is not ours to run at build time, however pure it looks, and
-* declining leaves exactly the behaviour that shipped before the checker was passed.
+* Called only after an evaluation has already failed. Everything that resolves today does so
+* without this, and an expression that reaches an unresolvable import used to be dropped
+* outright — so nothing that works pays for it, and nothing that pays for it was working.
 */
-const resolvesWithinProject = (node) => {
-	if (!Node.isCallExpression(node)) return false;
-	const symbol = node.getExpression().getSymbol();
-	if (!symbol) return false;
-	const declarations = (symbol.getAliasedSymbol() ?? symbol).getDeclarations();
-	if (!declarations.length) return false;
-	return !declarations.some((declaration) => declaration.getSourceFile().isInNodeModules());
+const importedEnvironmentFor = (node, ctx, stack, depth, evaluateExpression) => {
+	if (depth >= MAX_DEPTH) return;
+	const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
+	if (Node.isCallExpression(node)) calls.unshift(node);
+	if (!calls.length) return;
+	const bindings = importBindingsFor(node.getSourceFile());
+	if (!bindings.size) return;
+	let environment;
+	for (const call of calls) {
+		const callee = call.getExpression();
+		const binding = bindings.get(callee.getText());
+		if (!binding || environment?.[callee.getText()] !== void 0) continue;
+		const resolved = valueForBinding(binding, ctx, stack, depth, evaluateExpression);
+		if (!resolved) continue;
+		environment ??= {};
+		environment[callee.getText()] = resolved.value;
+	}
+	return environment;
 };
-/** One per project. `getTypeChecker()` is cheap, but this runs per evaluated call. */
-const typeCheckers = /* @__PURE__ */ new WeakMap();
-const typeCheckerFor = (node) => {
-	const project = node.getProject();
-	let checker = typeCheckers.get(project);
-	if (!checker) {
-		checker = project.getTypeChecker().compilerObject;
-		typeCheckers.set(project, checker);
+//#endregion
+//#region src/evaluate-node.ts
+const TsEvalError = Symbol("EvalError");
+const cacheMap$2 = /* @__PURE__ */ new WeakMap();
+/** @see https://github.com/wessberg/ts-evaluator#setting-up-policies */
+const POLICY = {
+	console: false,
+	deterministic: true,
+	io: {
+		read: true,
+		write: false
+	},
+	maxOpDuration: 1e3,
+	maxOps: Number.POSITIVE_INFINITY,
+	network: false,
+	process: {
+		exit: false,
+		spawnChild: false
 	}
-	return checker;
 };
 /**
-* Evaluates a node with strict policies restrictions
-* @see https://github.com/wessberg/ts-evaluator#setting-up-policies
+* Evaluates a node with strict policy restrictions.
+*
+* No type checker is passed. The evaluator accepts one, and it is the obvious way to let a
+* call reach a helper in another module — but asking TypeScript for a single symbol makes it
+* bind and check the entire program, `.d.ts` files included. That cost is paid by every
+* project on every build, scales with the size of the codebase rather than with the number
+* of style calls, and does not show up in a benchmark small enough to have no program to
+* check. See `resolve-imported-value.ts`, which crosses the import boundary directly for the
+* few expressions that need it.
 */
-const evaluateNode = (node, stack, ctx) => {
+const evaluateNode = (node, stack, ctx, depth = 0) => {
 	if (ctx.flags?.skipEvaluate) return;
 	if (ctx.canEval && !ctx.canEval?.(node, stack)) return;
-	if (cacheMap$2.has(node)) return cacheMap$2.get(node);
-	const result = evaluate({
-		...resolvesWithinProject(node) ? { typeChecker: typeCheckerFor(node) } : {},
-		policy: {
-			deterministic: true,
-			network: false,
-			console: false,
-			maxOps: Number.POSITIVE_INFINITY,
-			maxOpDuration: 1e3,
-			io: {
-				read: true,
-				write: false
-			},
-			process: {
-				exit: false,
-				spawnChild: false
-			}
-		},
+	if (depth === 0 && cacheMap$2.has(node)) return cacheMap$2.get(node);
+	const options = {
+		policy: { ...POLICY },
 		...ctx.getEvaluateOptions?.(node, stack),
 		node: node.compilerNode,
 		typescript: ts
-	});
+	};
+	let result = evaluate(options);
+	/**
+	* Retried only on failure, with whatever this expression imports put in scope.
+	*
+	* The order matters for cost. Everything that resolves today does so on the first attempt,
+	* so no working call pays anything for this — and an expression that reaches an
+	* unresolvable import was dropped outright before, so nothing that pays for it was
+	* working. Resolving imports up front instead would put a walk of every style object on
+	* the path of every build.
+	*/
+	if (!result.success) {
+		const imported = importedEnvironmentFor(node, ctx, stack, depth, safeEvaluateNode);
+		if (imported) result = evaluate({
+			...options,
+			environment: {
+				...options.environment,
+				extra: imported
+			}
+		});
+	}
 	const expr = result.success ? result.value : TsEvalError;
-	cacheMap$2.set(node, expr);
+	if (depth === 0) cacheMap$2.set(node, expr);
 	return expr;
 };
-const safeEvaluateNode = (node, stack, ctx) => {
-	const result = evaluateNode(node, stack, ctx);
+const safeEvaluateNode = (node, stack, ctx, depth = 0) => {
+	const result = evaluateNode(node, stack, ctx, depth);
 	if (result === TsEvalError) return;
 	return result;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamboocss/extractor",
-  "version": "1.17.1",
+  "version": "1.17.3",
   "description": "The css extractor for css bamboo",
   "homepage": "https://bamboocss.com",
   "license": "MIT",
@@ -35,7 +35,7 @@
   "dependencies": {
     "ts-evaluator": "1.2.0",
     "ts-morph": "28.0.0",
-    "@bamboocss/shared": "1.17.1"
+    "@bamboocss/shared": "1.17.3"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format=cjs,esm --shims --dts",