@bamboocss/extractor 1.12.2 → 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

@@ -336,12 +336,12 @@ function getDeclarationFor(node, stack, ctx) {
 	if ((ts_morph.Node.isVariableDeclaration(parent) || ts_morph.Node.isParameterDeclaration(parent) || ts_morph.Node.isFunctionDeclaration(parent) || ts_morph.Node.isEnumDeclaration(parent) || ts_morph.Node.isBindingElement(parent)) && parent.getNameNode() == node) {
 		declarationStack.push(parent);
 		declaration = parent;
-	} else if (ts_morph.Node.isImportSpecifier(parent) && parent.getNameNode() == node) {
+	} else if (ts_morph.Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node)) {
 		if (ctx.flags?.skipTraverseFiles) return;
 		const sourceFile = getModuleSpecifierSourceFile(parent.getImportDeclaration());
 		if (sourceFile) {
 			const exportStack = [parent, sourceFile];
-			const maybeVar = getExportedVarDeclarationWithName(node.getText(), sourceFile, exportStack, ctx);
+			const maybeVar = getExportedVarDeclarationWithName(parent.getNameNode().getText(), sourceFile, exportStack, ctx);
 			if (maybeVar) {
 				declarationStack.push(...exportStack.concat(maybeVar));
 				declaration = maybeVar;
@@ -508,9 +508,23 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 };
 //#endregion
 //#region src/maybe-box-node.ts
-const cacheMap$1 = /* @__PURE__ */ new WeakMap();
+let cacheMap$1 = /* @__PURE__ */ new WeakMap();
 const isCached = (node) => cacheMap$1.has(node);
 const getCached = (node) => cacheMap$1.get(node);
+/**
+* Drops every memoized resolution.
+*
+* The cache is keyed on AST nodes, and a node's resolved value can depend on
+* another file: `css(button)` folds whatever `./styles` exports. Editing that file
+* replaces only its own nodes, so an importer's nodes stay identical and would
+* otherwise keep serving the value read before the edit.
+*/
+const clearBoxNodeCache = () => {
+	if (!hasCachedEntries) return;
+	cacheMap$1 = /* @__PURE__ */ new WeakMap();
+	hasCachedEntries = false;
+};
+let hasCachedEntries = false;
 const isPlusSyntax = (op) => op === ts_morph.ts.SyntaxKind.PlusToken;
 const isLogicalSyntax = (op) => op === ts_morph.ts.SyntaxKind.BarBarToken || op === ts_morph.ts.SyntaxKind.QuestionQuestionToken || op === ts_morph.ts.SyntaxKind.AmpersandAmpersandToken || op === ts_morph.ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts_morph.ts.SyntaxKind.EqualsEqualsToken || op === ts_morph.ts.SyntaxKind.ExclamationEqualsEqualsToken || op === ts_morph.ts.SyntaxKind.ExclamationEqualsToken || op === ts_morph.ts.SyntaxKind.GreaterThanEqualsToken || op === ts_morph.ts.SyntaxKind.GreaterThanToken || op === ts_morph.ts.SyntaxKind.LessThanEqualsToken || op === ts_morph.ts.SyntaxKind.LessThanToken || op === ts_morph.ts.SyntaxKind.InstanceOfKeyword || op === ts_morph.ts.SyntaxKind.InKeyword;
 const isOperationSyntax = (op) => op === ts_morph.ts.SyntaxKind.AsteriskToken || op === ts_morph.ts.SyntaxKind.SlashToken || op === ts_morph.ts.SyntaxKind.PercentToken || op === ts_morph.ts.SyntaxKind.AsteriskAsteriskToken || op === ts_morph.ts.SyntaxKind.MinusToken;
@@ -520,6 +534,7 @@ const canReturnWhenTrueInLogicalExpression = (op) => {
 function maybeBoxNode(node, stack, ctx, matchProp) {
 	const cache = (value) => {
 		cacheMap$1.set(node, value);
+		hasCachedEntries = true;
 		return value;
 	};
 	if (isCached(node)) return getCached(node);
@@ -916,17 +931,29 @@ const maybeDefinitionValue = (def, stack, ctx) => {
 		if (maybeValue) return maybeValue;
 	}
 };
-const getExportedVarDeclarationWithName = (varName, sourceFile, stack, ctx) => {
+const getExportedVarDeclarationWithName = (varName, sourceFile, stack, ctx, visited = /* @__PURE__ */ new Set()) => {
+	const key = `${sourceFile.getFilePath()}:${varName}`;
+	if (visited.has(key)) return;
+	visited.add(key);
 	const maybeVar = sourceFile.getVariableDeclaration(varName);
 	if (maybeVar) return maybeVar;
-	const exportDeclaration = resolveVarDeclarationFromExportWithName(varName, sourceFile, stack, ctx);
+	const exportDeclaration = resolveVarDeclarationFromExportWithName(varName, sourceFile, stack, ctx, visited);
 	if (!exportDeclaration) return;
 	return exportDeclaration;
 };
-const hasNamedExportWithName = (name, exportDeclaration) => {
+/**
+* Given the name a module exposes, the name to look for in the module it came from.
+* Returns `undefined` when this declaration does not provide `name` at all.
+*
+* For `export { btn as button } from './styles'` the two differ: `getAliasNode()`
+* is `button`, the name this module exports, and `getNameNode()` is `btn`, the name
+* to search for in `./styles`. Matching on the wrong one both hides names the
+* module does export and resolves names it does not.
+*/
+const resolveExportedName = (name, exportDeclaration) => {
 	const namedExports = exportDeclaration.getNamedExports();
-	if (namedExports.length === 0) return true;
-	for (const namedExport of namedExports) if (namedExport.getNameNode().getText() === name) return true;
+	if (namedExports.length === 0) return name;
+	for (const namedExport of namedExports) if ((namedExport.getAliasNode() ?? namedExport.getNameNode()).getText() === name) return namedExport.getNameNode().getText();
 };
 /**
 * Faster than declaration.getModuleSpecifierSourceFile()
@@ -946,14 +973,22 @@ const getModuleSpecifierSourceFile = (declaration) => {
 	if (!resolved.resolvedModule) return;
 	return project.addSourceFileAtPath(resolved.resolvedModule.resolvedFileName);
 };
-function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx) {
+function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx, visited) {
 	for (const exportDeclaration of sourceFile.getExportDeclarations()) {
 		const exportStack = [exportDeclaration];
-		if (!hasNamedExportWithName(symbolName, exportDeclaration)) continue;
+		const sourceName = resolveExportedName(symbolName, exportDeclaration);
+		if (sourceName === void 0) continue;
 		const maybeFile = getModuleSpecifierSourceFile(exportDeclaration);
-		if (!maybeFile) continue;
+		if (!maybeFile) {
+			const localVar = sourceFile.getVariableDeclaration(sourceName);
+			if (localVar) {
+				stack.push(...exportStack.concat(localVar));
+				return localVar;
+			}
+			continue;
+		}
 		exportStack.push(maybeFile);
-		const maybeVar = getExportedVarDeclarationWithName(symbolName, maybeFile, stack, ctx);
+		const maybeVar = getExportedVarDeclarationWithName(sourceName, maybeFile, stack, ctx, visited);
 		if (maybeVar) {
 			stack.push(...exportStack.concat(maybeVar));
 			return maybeVar;
@@ -1820,6 +1855,7 @@ exports.BoxNodeMap = BoxNodeMap;
 exports.BoxNodeObject = BoxNodeObject;
 exports.BoxNodeUnresolvable = BoxNodeUnresolvable;
 exports.box = box;
+exports.clearBoxNodeCache = clearBoxNodeCache;
 exports.extract = extract;
 exports.extractCallExpressionArguments = extractCallExpressionArguments;
 exports.extractJsxAttribute = extractJsxAttribute;

package/dist/index.d.cts

@@ -0,0 +1,312 @@
+import { BindingElement, CallExpression, EnumDeclaration, Expression, FunctionDeclaration, GetAccessorDeclaration, Identifier, JsxAttribute, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, Node, ParameterDeclaration, PropertyAssignment, ShorthandPropertyAssignment, SourceFile, TaggedTemplateExpression, VariableDeclaration } from "ts-morph";
+import { EvaluateOptions as EvaluateOptions$1 } from "ts-evaluator";
+
+//#region src/box-factory.d.ts
+interface WithNode {
+  node: Node;
+  stack: Node[];
+}
+interface ObjectType extends WithNode {
+  type: 'object';
+  value: EvaluatedObjectResult;
+  isEmpty?: boolean;
+}
+type LiteralKind = 'array' | 'string' | 'number' | 'boolean' | 'null' | 'undefined';
+interface LiteralType extends WithNode {
+  type: 'literal';
+  value: PrimitiveType;
+  kind: LiteralKind;
+}
+interface MapType extends WithNode {
+  type: 'map';
+  value: MapTypeValue;
+}
+interface ArrayType extends WithNode {
+  type: 'array';
+  value: BoxNode[];
+}
+interface UnresolvableType extends WithNode {
+  type: 'unresolvable';
+}
+interface ConditionalType extends WithNode {
+  type: 'conditional';
+  whenTrue: BoxNode;
+  whenFalse: BoxNode;
+}
+/** -> Jsx boolean attribute <Box flex /> */
+interface EmptyInitializerType extends WithNode {
+  type: 'empty-initializer';
+}
+type BoxNodeDefinition = ObjectType | LiteralType | MapType | ArrayType | UnresolvableType | ConditionalType | EmptyInitializerType;
+type BoxNode = BoxNodeObject | BoxNodeLiteral | BoxNodeMap | BoxNodeArray | BoxNodeUnresolvable | BoxNodeConditional | BoxNodeEmptyInitializer;
+type MapTypeValue = Map<string, BoxNode>;
+declare abstract class BoxNodeType$1<Definition extends BoxNodeDefinition = BoxNodeDefinition> {
+  readonly type: Definition['type'];
+  private readonly stack;
+  private readonly node;
+  constructor(definition: Definition);
+  getNode(): Node;
+  getStack(): Node[];
+  getRange: () => {
+    startPosition: number;
+    startLineNumber: number;
+    startColumn: number;
+    endPosition: number;
+    endLineNumber: number;
+    endColumn: number;
+  };
+  toJSON(): {
+    type: Definition["type"];
+    value: any;
+    node: string;
+    line: number;
+    column: number;
+    endLineNumber: number;
+    endColumn: number;
+  };
+  toString(): string;
+}
+declare class BoxNodeObject extends BoxNodeType$1<ObjectType> {
+  value: ObjectType['value'];
+  isEmpty: ObjectType['isEmpty'];
+  constructor(definition: ObjectType);
+}
+declare class BoxNodeLiteral extends BoxNodeType$1<LiteralType> {
+  value: LiteralType['value'];
+  kind: LiteralType['kind'];
+  constructor(definition: LiteralType);
+}
+declare class BoxNodeMap extends BoxNodeType$1<MapType> {
+  value: MapType['value'];
+  spreadConditions?: BoxNodeConditional[];
+  constructor(definition: MapType);
+  isRecipe: () => boolean;
+}
+declare class BoxNodeArray extends BoxNodeType$1<ArrayType> {
+  value: ArrayType['value'];
+  constructor(definition: ArrayType);
+}
+declare class BoxNodeUnresolvable extends BoxNodeType$1<UnresolvableType> {}
+declare class BoxNodeConditional extends BoxNodeType$1<ConditionalType> {
+  whenTrue: ConditionalType['whenTrue'];
+  whenFalse: ConditionalType['whenFalse'];
+  constructor(definition: ConditionalType);
+}
+declare class BoxNodeEmptyInitializer extends BoxNodeType$1<EmptyInitializerType> {}
+declare const isBoxNode: (value: unknown) => value is BoxNode;
+//#endregion
+//#region src/types.d.ts
+type PrimitiveType = string | number | boolean | null | undefined;
+interface LiteralObject {
+  [key: string]: any;
+}
+type SingleLiteralValue = PrimitiveType | LiteralObject;
+type LiteralValue = SingleLiteralValue | SingleLiteralValue[];
+interface EvaluatedObjectResult {
+  [key: string]: LiteralValue;
+}
+interface ExtractedFunctionInstance {
+  name: string;
+  kind: 'call-expression';
+  fromNode: () => CallExpression;
+  box: BoxNodeArray;
+}
+interface ExtractedTaggedTemplateInstance {
+  name: string;
+  kind: 'tagged-template';
+  fromNode: () => TaggedTemplateExpression;
+  box: BoxNodeLiteral;
+}
+interface ExtractedFunctionResult {
+  kind: 'function';
+  nodesByProp: Map<string, BoxNode[]>;
+  queryList: Array<ExtractedFunctionInstance | ExtractedTaggedTemplateInstance>;
+}
+interface ExtractedComponentInstance {
+  name: string;
+  fromNode: () => JsxOpeningElement | JsxSelfClosingElement | CallExpression;
+  box: BoxNodeMap;
+}
+interface ExtractedComponentResult {
+  kind: 'component';
+  nodesByProp: Map<string, BoxNode[]>;
+  queryList: ExtractedComponentInstance[];
+}
+type ExtractResultItem = ExtractedComponentResult | ExtractedFunctionResult;
+type ExtractResultByName = Map<string, ExtractResultItem>;
+interface MatchTagArgs {
+  tagName: string;
+  tagNode: JsxOpeningElement | JsxSelfClosingElement | CallExpression;
+  isFactory: boolean;
+}
+interface MatchPropArgs {
+  propName: string;
+  propNode: JsxAttribute | PropertyAssignment | ShorthandPropertyAssignment | GetAccessorDeclaration | undefined;
+}
+interface MatchFnArgs {
+  fnName: string;
+  fnNode: CallExpression;
+}
+interface MatchFnArguments {
+  argNode: Node;
+  index: number;
+}
+interface MatchFnPropArgs {
+  propName: string;
+  propNode: PropertyAssignment | ShorthandPropertyAssignment | GetAccessorDeclaration;
+}
+interface FunctionMatchers {
+  matchFn: (element: MatchFnArgs) => boolean;
+  matchArg: (arg: Pick<MatchFnArgs, 'fnName' | 'fnNode'> & MatchFnArguments) => boolean;
+  matchProp: (prop: Pick<MatchFnArgs, 'fnName' | 'fnNode'> & MatchFnPropArgs) => boolean;
+}
+interface ComponentMatchers {
+  matchTag: (element: MatchTagArgs) => boolean;
+  matchProp: (prop: Pick<MatchTagArgs, 'tagName' | 'tagNode'> & MatchPropArgs) => boolean;
+}
+interface MatchTaggedTemplateArgs {
+  fnName: string;
+  taggedTemplateNode: TaggedTemplateExpression;
+}
+type MatchTaggedTemplate = (tag: MatchTaggedTemplateArgs) => boolean;
+interface BoxContext {
+  getEvaluateOptions?: (node: Expression, stack: Node[]) => Omit<EvaluateOptions, 'node' | 'policy'> | void;
+  canEval?: (node: Expression, stack: Node[]) => boolean;
+  tokens?: {
+    view: {
+      get: (path: string, fallback?: string | number) => string | undefined;
+      getVar: (path: string, fallback?: string | number) => string | undefined;
+    };
+    isTokenFn?: (fnName: string) => boolean;
+  };
+  flags?: {
+    skipEvaluate?: boolean;
+    skipTraverseFiles?: boolean;
+    skipConditions?: boolean;
+  };
+}
+type EvaluateOptions = Omit<EvaluateOptions$1, 'node' | 'policy'>;
+type ExtractOptions = BoxContext & {
+  ast: SourceFile;
+  components?: ComponentMatchers;
+  functions?: FunctionMatchers;
+  taggedTemplates?: {
+    matchTaggedTemplate: MatchTaggedTemplate;
+  };
+};
+//#endregion
+//#region src/to-box-node.d.ts
+declare function toBoxNode<Value extends PrimitiveType>(value: Value, node: Node, stack: Node[]): BoxNodeLiteral;
+declare function toBoxNode<Value extends EvaluatedObjectResult>(value: Value, node: Node, stack: Node[]): BoxNodeObject;
+declare function toBoxNode<Value extends PrimitiveType[]>(value: Value, node: Node, stack: Node[]): BoxNodeLiteral[];
+declare function toBoxNode<Value extends BoxNode | BoxNode[]>(value: Value, node: Node, stack: Node[]): Value;
+declare function toBoxNode<Value extends LiteralValue>(value: Value, node: Node, stack: Node[]): Value extends unknown[] ? BoxNodeLiteral : Value extends PrimitiveType ? BoxNodeLiteral : BoxNodeObject;
+declare function toBoxNode<Value extends PrimitiveType | BoxNode>(value: Value, node: Node, stack: Node[]): BoxNodeLiteral;
+//#endregion
+//#region src/box.d.ts
+declare const box: {
+  object(value: EvaluatedObjectResult, node: Node, stack: Node[]): BoxNodeObject;
+  literal(value: PrimitiveType, node: Node, stack: Node[]): BoxNodeLiteral;
+  map(value: MapTypeValue, node: Node, stack: Node[]): BoxNodeMap;
+  array(value: BoxNode[], node: Node, stack: Node[]): BoxNodeArray;
+  conditional(whenTrue: BoxNode, whenFalse: BoxNode, node: Node, stack: Node[]): BoxNodeConditional;
+  from: typeof toBoxNode;
+  objectToMap: (value: Record<string, unknown>, node: Node, stack: Node[]) => BoxNodeMap;
+  emptyObject: (node: Node, stack: Node[]) => BoxNodeObject;
+  emptyInitializer: (node: Node, stack: Node[]) => BoxNodeEmptyInitializer;
+  unresolvable: (node: Node, stack: Node[]) => BoxNodeUnresolvable;
+  fallback(node: BoxNode): BoxNode;
+  /**
+   * box.type === “object” -> object that was resolved using ts-evaluator, most likely from a
+   * complex condition OR a simple CallExpression eval result, we don’t have access to individual
+   * AST nodes here so we need the distinction
+   */
+  isObject(value: BoxNode | undefined): value is BoxNodeObject;
+  isLiteral(value: BoxNode | undefined): value is BoxNodeLiteral;
+  /**
+   * box.type === “map” -> basically any object that was statically analyzable, we store each
+   * prop + value in a Map
+   */
+  isMap(value: BoxNode | undefined): value is BoxNodeMap;
+  isRecipe(value: BoxNode | undefined): value is BoxNodeMap;
+  isArray(value: BoxNode | undefined): value is BoxNodeArray;
+  isUnresolvable(value: BoxNode | undefined): value is BoxNodeUnresolvable;
+  isConditional(value: BoxNode | undefined): value is BoxNodeConditional;
+  isEmptyInitializer(value: BoxNode | undefined): value is BoxNodeEmptyInitializer;
+  isNumberLiteral(node: BoxNode | undefined): node is BoxNodeLiteral;
+  hasValue: (node: BoxNode | undefined) => node is BoxNodeLiteral | BoxNodeObject | BoxNodeMap | BoxNodeArray;
+};
+//#endregion
+//#region src/call-expression.d.ts
+type MatchProp$1 = (prop: MatchFnPropArgs) => boolean;
+type MatchArg = (prop: MatchFnArgs & MatchFnArguments) => boolean;
+declare const extractCallExpressionArguments: (node: CallExpression, ctx: BoxContext, matchProp?: MatchProp$1, matchArg?: MatchArg) => BoxNodeArray;
+//#endregion
+//#region src/extract.d.ts
+declare const extract: ({
+  ast,
+  ...ctx
+}: ExtractOptions) => ExtractResultByName;
+//#endregion
+//#region src/find-identifier-value-declaration.d.ts
+declare function getDeclarationFor(node: Identifier, stack: Node[], ctx: BoxContext): VariableDeclaration | ParameterDeclaration | FunctionDeclaration | EnumDeclaration | BindingElement | undefined;
+declare function findIdentifierValueDeclaration(identifier: Identifier, stack: Node[], ctx: BoxContext, visitedsWithStack?: WeakMap<Node, Node[]>): ReturnType<typeof getDeclarationFor> | undefined;
+//#endregion
+//#region src/get-node-range.d.ts
+declare const getNodeRange: (node: Node) => {
+  startPosition: number;
+  startLineNumber: number;
+  startColumn: number;
+  endPosition: number;
+  endLineNumber: number;
+  endColumn: number;
+};
+type NodeRange = ReturnType<typeof getNodeRange>;
+//#endregion
+//#region src/jsx-attribute.d.ts
+declare const extractJsxAttribute: (jsxAttribute: JsxAttribute, ctx: BoxContext) => BoxNode | undefined;
+//#endregion
+//#region src/jsx-element-props.d.ts
+declare const extractJsxElementProps: (node: JsxOpeningElement | JsxSelfClosingElement, ctx: BoxContext) => {
+  name: string;
+  props: Map<string, BoxNode>;
+};
+//#endregion
+//#region src/maybe-box-node.d.ts
+/**
+ * Drops every memoized resolution.
+ *
+ * The cache is keyed on AST nodes, and a node's resolved value can depend on
+ * another file: `css(button)` folds whatever `./styles` exports. Editing that file
+ * replaces only its own nodes, so an importer's nodes stay identical and would
+ * otherwise keep serving the value read before the edit.
+ */
+declare const clearBoxNodeCache: () => void;
+type MaybeBoxNodeReturn = BoxNode | undefined;
+declare function maybeBoxNode(node: Node, stack: Node[], ctx: BoxContext, matchProp?: (prop: MatchFnPropArgs) => boolean): MaybeBoxNodeReturn;
+declare const maybeIdentifierValue: (identifier: Identifier, _stack: Node[], ctx: BoxContext) => BoxNode;
+//#endregion
+//#region src/jsx-spread-attribute.d.ts
+type MatchProp = (prop: MatchFnPropArgs | MatchPropArgs) => boolean;
+declare const extractJsxSpreadAttributeValues: (node: JsxSpreadAttribute, ctx: BoxContext, matchProp: MatchProp) => MaybeBoxNodeReturn;
+//#endregion
+//#region src/unbox.d.ts
+type BoxNodeType = BoxNode | BoxNode[] | undefined;
+type CacheMap = WeakMap<BoxNode, Unboxed>;
+interface UnboxContext {
+  path: string[];
+  parent: BoxNode | undefined;
+  cache: CacheMap;
+  /** @example <ColorBox color={unresolvableIdentifier ? "light.100" : "dark.200" } /> */
+  conditions: LiteralObject[];
+  /** @example <ColorBox {...(someCondition && { color: "blue.100" })} /> */
+  spreadConditions: LiteralObject[];
+}
+interface Unboxed {
+  raw: LiteralObject;
+  conditions: LiteralObject[];
+  spreadConditions: LiteralObject[];
+}
+declare const unbox: (node: BoxNodeType, ctx?: Pick<UnboxContext, "cache">) => Unboxed;
+//#endregion
+export { type BoxContext, type BoxNode, BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, type EvaluateOptions, type ExtractOptions, type ExtractResultByName, type ExtractResultItem, type ExtractedComponentInstance, type ExtractedComponentResult, type ExtractedFunctionInstance, type ExtractedFunctionResult, type NodeRange, type PrimitiveType, type Unboxed, box, clearBoxNodeCache, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox };

package/dist/index.d.mts

@@ -0,0 +1,312 @@
+import { BindingElement, CallExpression, EnumDeclaration, Expression, FunctionDeclaration, GetAccessorDeclaration, Identifier, JsxAttribute, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, Node, ParameterDeclaration, PropertyAssignment, ShorthandPropertyAssignment, SourceFile, TaggedTemplateExpression, VariableDeclaration } from "ts-morph";
+import { EvaluateOptions as EvaluateOptions$1 } from "ts-evaluator";
+
+//#region src/box-factory.d.ts
+interface WithNode {
+  node: Node;
+  stack: Node[];
+}
+interface ObjectType extends WithNode {
+  type: 'object';
+  value: EvaluatedObjectResult;
+  isEmpty?: boolean;
+}
+type LiteralKind = 'array' | 'string' | 'number' | 'boolean' | 'null' | 'undefined';
+interface LiteralType extends WithNode {
+  type: 'literal';
+  value: PrimitiveType;
+  kind: LiteralKind;
+}
+interface MapType extends WithNode {
+  type: 'map';
+  value: MapTypeValue;
+}
+interface ArrayType extends WithNode {
+  type: 'array';
+  value: BoxNode[];
+}
+interface UnresolvableType extends WithNode {
+  type: 'unresolvable';
+}
+interface ConditionalType extends WithNode {
+  type: 'conditional';
+  whenTrue: BoxNode;
+  whenFalse: BoxNode;
+}
+/** -> Jsx boolean attribute <Box flex /> */
+interface EmptyInitializerType extends WithNode {
+  type: 'empty-initializer';
+}
+type BoxNodeDefinition = ObjectType | LiteralType | MapType | ArrayType | UnresolvableType | ConditionalType | EmptyInitializerType;
+type BoxNode = BoxNodeObject | BoxNodeLiteral | BoxNodeMap | BoxNodeArray | BoxNodeUnresolvable | BoxNodeConditional | BoxNodeEmptyInitializer;
+type MapTypeValue = Map<string, BoxNode>;
+declare abstract class BoxNodeType$1<Definition extends BoxNodeDefinition = BoxNodeDefinition> {
+  readonly type: Definition['type'];
+  private readonly stack;
+  private readonly node;
+  constructor(definition: Definition);
+  getNode(): Node;
+  getStack(): Node[];
+  getRange: () => {
+    startPosition: number;
+    startLineNumber: number;
+    startColumn: number;
+    endPosition: number;
+    endLineNumber: number;
+    endColumn: number;
+  };
+  toJSON(): {
+    type: Definition["type"];
+    value: any;
+    node: string;
+    line: number;
+    column: number;
+    endLineNumber: number;
+    endColumn: number;
+  };
+  toString(): string;
+}
+declare class BoxNodeObject extends BoxNodeType$1<ObjectType> {
+  value: ObjectType['value'];
+  isEmpty: ObjectType['isEmpty'];
+  constructor(definition: ObjectType);
+}
+declare class BoxNodeLiteral extends BoxNodeType$1<LiteralType> {
+  value: LiteralType['value'];
+  kind: LiteralType['kind'];
+  constructor(definition: LiteralType);
+}
+declare class BoxNodeMap extends BoxNodeType$1<MapType> {
+  value: MapType['value'];
+  spreadConditions?: BoxNodeConditional[];
+  constructor(definition: MapType);
+  isRecipe: () => boolean;
+}
+declare class BoxNodeArray extends BoxNodeType$1<ArrayType> {
+  value: ArrayType['value'];
+  constructor(definition: ArrayType);
+}
+declare class BoxNodeUnresolvable extends BoxNodeType$1<UnresolvableType> {}
+declare class BoxNodeConditional extends BoxNodeType$1<ConditionalType> {
+  whenTrue: ConditionalType['whenTrue'];
+  whenFalse: ConditionalType['whenFalse'];
+  constructor(definition: ConditionalType);
+}
+declare class BoxNodeEmptyInitializer extends BoxNodeType$1<EmptyInitializerType> {}
+declare const isBoxNode: (value: unknown) => value is BoxNode;
+//#endregion
+//#region src/types.d.ts
+type PrimitiveType = string | number | boolean | null | undefined;
+interface LiteralObject {
+  [key: string]: any;
+}
+type SingleLiteralValue = PrimitiveType | LiteralObject;
+type LiteralValue = SingleLiteralValue | SingleLiteralValue[];
+interface EvaluatedObjectResult {
+  [key: string]: LiteralValue;
+}
+interface ExtractedFunctionInstance {
+  name: string;
+  kind: 'call-expression';
+  fromNode: () => CallExpression;
+  box: BoxNodeArray;
+}
+interface ExtractedTaggedTemplateInstance {
+  name: string;
+  kind: 'tagged-template';
+  fromNode: () => TaggedTemplateExpression;
+  box: BoxNodeLiteral;
+}
+interface ExtractedFunctionResult {
+  kind: 'function';
+  nodesByProp: Map<string, BoxNode[]>;
+  queryList: Array<ExtractedFunctionInstance | ExtractedTaggedTemplateInstance>;
+}
+interface ExtractedComponentInstance {
+  name: string;
+  fromNode: () => JsxOpeningElement | JsxSelfClosingElement | CallExpression;
+  box: BoxNodeMap;
+}
+interface ExtractedComponentResult {
+  kind: 'component';
+  nodesByProp: Map<string, BoxNode[]>;
+  queryList: ExtractedComponentInstance[];
+}
+type ExtractResultItem = ExtractedComponentResult | ExtractedFunctionResult;
+type ExtractResultByName = Map<string, ExtractResultItem>;
+interface MatchTagArgs {
+  tagName: string;
+  tagNode: JsxOpeningElement | JsxSelfClosingElement | CallExpression;
+  isFactory: boolean;
+}
+interface MatchPropArgs {
+  propName: string;
+  propNode: JsxAttribute | PropertyAssignment | ShorthandPropertyAssignment | GetAccessorDeclaration | undefined;
+}
+interface MatchFnArgs {
+  fnName: string;
+  fnNode: CallExpression;
+}
+interface MatchFnArguments {
+  argNode: Node;
+  index: number;
+}
+interface MatchFnPropArgs {
+  propName: string;
+  propNode: PropertyAssignment | ShorthandPropertyAssignment | GetAccessorDeclaration;
+}
+interface FunctionMatchers {
+  matchFn: (element: MatchFnArgs) => boolean;
+  matchArg: (arg: Pick<MatchFnArgs, 'fnName' | 'fnNode'> & MatchFnArguments) => boolean;
+  matchProp: (prop: Pick<MatchFnArgs, 'fnName' | 'fnNode'> & MatchFnPropArgs) => boolean;
+}
+interface ComponentMatchers {
+  matchTag: (element: MatchTagArgs) => boolean;
+  matchProp: (prop: Pick<MatchTagArgs, 'tagName' | 'tagNode'> & MatchPropArgs) => boolean;
+}
+interface MatchTaggedTemplateArgs {
+  fnName: string;
+  taggedTemplateNode: TaggedTemplateExpression;
+}
+type MatchTaggedTemplate = (tag: MatchTaggedTemplateArgs) => boolean;
+interface BoxContext {
+  getEvaluateOptions?: (node: Expression, stack: Node[]) => Omit<EvaluateOptions, 'node' | 'policy'> | void;
+  canEval?: (node: Expression, stack: Node[]) => boolean;
+  tokens?: {
+    view: {
+      get: (path: string, fallback?: string | number) => string | undefined;
+      getVar: (path: string, fallback?: string | number) => string | undefined;
+    };
+    isTokenFn?: (fnName: string) => boolean;
+  };
+  flags?: {
+    skipEvaluate?: boolean;
+    skipTraverseFiles?: boolean;
+    skipConditions?: boolean;
+  };
+}
+type EvaluateOptions = Omit<EvaluateOptions$1, 'node' | 'policy'>;
+type ExtractOptions = BoxContext & {
+  ast: SourceFile;
+  components?: ComponentMatchers;
+  functions?: FunctionMatchers;
+  taggedTemplates?: {
+    matchTaggedTemplate: MatchTaggedTemplate;
+  };
+};
+//#endregion
+//#region src/to-box-node.d.ts
+declare function toBoxNode<Value extends PrimitiveType>(value: Value, node: Node, stack: Node[]): BoxNodeLiteral;
+declare function toBoxNode<Value extends EvaluatedObjectResult>(value: Value, node: Node, stack: Node[]): BoxNodeObject;
+declare function toBoxNode<Value extends PrimitiveType[]>(value: Value, node: Node, stack: Node[]): BoxNodeLiteral[];
+declare function toBoxNode<Value extends BoxNode | BoxNode[]>(value: Value, node: Node, stack: Node[]): Value;
+declare function toBoxNode<Value extends LiteralValue>(value: Value, node: Node, stack: Node[]): Value extends unknown[] ? BoxNodeLiteral : Value extends PrimitiveType ? BoxNodeLiteral : BoxNodeObject;
+declare function toBoxNode<Value extends PrimitiveType | BoxNode>(value: Value, node: Node, stack: Node[]): BoxNodeLiteral;
+//#endregion
+//#region src/box.d.ts
+declare const box: {
+  object(value: EvaluatedObjectResult, node: Node, stack: Node[]): BoxNodeObject;
+  literal(value: PrimitiveType, node: Node, stack: Node[]): BoxNodeLiteral;
+  map(value: MapTypeValue, node: Node, stack: Node[]): BoxNodeMap;
+  array(value: BoxNode[], node: Node, stack: Node[]): BoxNodeArray;
+  conditional(whenTrue: BoxNode, whenFalse: BoxNode, node: Node, stack: Node[]): BoxNodeConditional;
+  from: typeof toBoxNode;
+  objectToMap: (value: Record<string, unknown>, node: Node, stack: Node[]) => BoxNodeMap;
+  emptyObject: (node: Node, stack: Node[]) => BoxNodeObject;
+  emptyInitializer: (node: Node, stack: Node[]) => BoxNodeEmptyInitializer;
+  unresolvable: (node: Node, stack: Node[]) => BoxNodeUnresolvable;
+  fallback(node: BoxNode): BoxNode;
+  /**
+   * box.type === “object” -> object that was resolved using ts-evaluator, most likely from a
+   * complex condition OR a simple CallExpression eval result, we don’t have access to individual
+   * AST nodes here so we need the distinction
+   */
+  isObject(value: BoxNode | undefined): value is BoxNodeObject;
+  isLiteral(value: BoxNode | undefined): value is BoxNodeLiteral;
+  /**
+   * box.type === “map” -> basically any object that was statically analyzable, we store each
+   * prop + value in a Map
+   */
+  isMap(value: BoxNode | undefined): value is BoxNodeMap;
+  isRecipe(value: BoxNode | undefined): value is BoxNodeMap;
+  isArray(value: BoxNode | undefined): value is BoxNodeArray;
+  isUnresolvable(value: BoxNode | undefined): value is BoxNodeUnresolvable;
+  isConditional(value: BoxNode | undefined): value is BoxNodeConditional;
+  isEmptyInitializer(value: BoxNode | undefined): value is BoxNodeEmptyInitializer;
+  isNumberLiteral(node: BoxNode | undefined): node is BoxNodeLiteral;
+  hasValue: (node: BoxNode | undefined) => node is BoxNodeLiteral | BoxNodeObject | BoxNodeMap | BoxNodeArray;
+};
+//#endregion
+//#region src/call-expression.d.ts
+type MatchProp$1 = (prop: MatchFnPropArgs) => boolean;
+type MatchArg = (prop: MatchFnArgs & MatchFnArguments) => boolean;
+declare const extractCallExpressionArguments: (node: CallExpression, ctx: BoxContext, matchProp?: MatchProp$1, matchArg?: MatchArg) => BoxNodeArray;
+//#endregion
+//#region src/extract.d.ts
+declare const extract: ({
+  ast,
+  ...ctx
+}: ExtractOptions) => ExtractResultByName;
+//#endregion
+//#region src/find-identifier-value-declaration.d.ts
+declare function getDeclarationFor(node: Identifier, stack: Node[], ctx: BoxContext): VariableDeclaration | ParameterDeclaration | FunctionDeclaration | EnumDeclaration | BindingElement | undefined;
+declare function findIdentifierValueDeclaration(identifier: Identifier, stack: Node[], ctx: BoxContext, visitedsWithStack?: WeakMap<Node, Node[]>): ReturnType<typeof getDeclarationFor> | undefined;
+//#endregion
+//#region src/get-node-range.d.ts
+declare const getNodeRange: (node: Node) => {
+  startPosition: number;
+  startLineNumber: number;
+  startColumn: number;
+  endPosition: number;
+  endLineNumber: number;
+  endColumn: number;
+};
+type NodeRange = ReturnType<typeof getNodeRange>;
+//#endregion
+//#region src/jsx-attribute.d.ts
+declare const extractJsxAttribute: (jsxAttribute: JsxAttribute, ctx: BoxContext) => BoxNode | undefined;
+//#endregion
+//#region src/jsx-element-props.d.ts
+declare const extractJsxElementProps: (node: JsxOpeningElement | JsxSelfClosingElement, ctx: BoxContext) => {
+  name: string;
+  props: Map<string, BoxNode>;
+};
+//#endregion
+//#region src/maybe-box-node.d.ts
+/**
+ * Drops every memoized resolution.
+ *
+ * The cache is keyed on AST nodes, and a node's resolved value can depend on
+ * another file: `css(button)` folds whatever `./styles` exports. Editing that file
+ * replaces only its own nodes, so an importer's nodes stay identical and would
+ * otherwise keep serving the value read before the edit.
+ */
+declare const clearBoxNodeCache: () => void;
+type MaybeBoxNodeReturn = BoxNode | undefined;
+declare function maybeBoxNode(node: Node, stack: Node[], ctx: BoxContext, matchProp?: (prop: MatchFnPropArgs) => boolean): MaybeBoxNodeReturn;
+declare const maybeIdentifierValue: (identifier: Identifier, _stack: Node[], ctx: BoxContext) => BoxNode;
+//#endregion
+//#region src/jsx-spread-attribute.d.ts
+type MatchProp = (prop: MatchFnPropArgs | MatchPropArgs) => boolean;
+declare const extractJsxSpreadAttributeValues: (node: JsxSpreadAttribute, ctx: BoxContext, matchProp: MatchProp) => MaybeBoxNodeReturn;
+//#endregion
+//#region src/unbox.d.ts
+type BoxNodeType = BoxNode | BoxNode[] | undefined;
+type CacheMap = WeakMap<BoxNode, Unboxed>;
+interface UnboxContext {
+  path: string[];
+  parent: BoxNode | undefined;
+  cache: CacheMap;
+  /** @example <ColorBox color={unresolvableIdentifier ? "light.100" : "dark.200" } /> */
+  conditions: LiteralObject[];
+  /** @example <ColorBox {...(someCondition && { color: "blue.100" })} /> */
+  spreadConditions: LiteralObject[];
+}
+interface Unboxed {
+  raw: LiteralObject;
+  conditions: LiteralObject[];
+  spreadConditions: LiteralObject[];
+}
+declare const unbox: (node: BoxNodeType, ctx?: Pick<UnboxContext, "cache">) => Unboxed;
+//#endregion
+export { type BoxContext, type BoxNode, BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, type EvaluateOptions, type ExtractOptions, type ExtractResultByName, type ExtractResultItem, type ExtractedComponentInstance, type ExtractedComponentResult, type ExtractedFunctionInstance, type ExtractedFunctionResult, type NodeRange, type PrimitiveType, type Unboxed, box, clearBoxNodeCache, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox };

package/dist/index.mjs

@@ -335,12 +335,12 @@ function getDeclarationFor(node, stack, ctx) {
 	if ((Node.isVariableDeclaration(parent) || Node.isParameterDeclaration(parent) || Node.isFunctionDeclaration(parent) || Node.isEnumDeclaration(parent) || Node.isBindingElement(parent)) && parent.getNameNode() == node) {
 		declarationStack.push(parent);
 		declaration = parent;
-	} else if (Node.isImportSpecifier(parent) && parent.getNameNode() == node) {
+	} else if (Node.isImportSpecifier(parent) && (parent.getNameNode() == node || parent.getAliasNode() == node)) {
 		if (ctx.flags?.skipTraverseFiles) return;
 		const sourceFile = getModuleSpecifierSourceFile(parent.getImportDeclaration());
 		if (sourceFile) {
 			const exportStack = [parent, sourceFile];
-			const maybeVar = getExportedVarDeclarationWithName(node.getText(), sourceFile, exportStack, ctx);
+			const maybeVar = getExportedVarDeclarationWithName(parent.getNameNode().getText(), sourceFile, exportStack, ctx);
 			if (maybeVar) {
 				declarationStack.push(...exportStack.concat(maybeVar));
 				declaration = maybeVar;
@@ -507,9 +507,23 @@ const getObjectLiteralExpressionPropPairs = (expression, expressionStack, ctx, m
 };
 //#endregion
 //#region src/maybe-box-node.ts
-const cacheMap$1 = /* @__PURE__ */ new WeakMap();
+let cacheMap$1 = /* @__PURE__ */ new WeakMap();
 const isCached = (node) => cacheMap$1.has(node);
 const getCached = (node) => cacheMap$1.get(node);
+/**
+* Drops every memoized resolution.
+*
+* The cache is keyed on AST nodes, and a node's resolved value can depend on
+* another file: `css(button)` folds whatever `./styles` exports. Editing that file
+* replaces only its own nodes, so an importer's nodes stay identical and would
+* otherwise keep serving the value read before the edit.
+*/
+const clearBoxNodeCache = () => {
+	if (!hasCachedEntries) return;
+	cacheMap$1 = /* @__PURE__ */ new WeakMap();
+	hasCachedEntries = false;
+};
+let hasCachedEntries = false;
 const isPlusSyntax = (op) => op === ts.SyntaxKind.PlusToken;
 const isLogicalSyntax = (op) => op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken || op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken || op === ts.SyntaxKind.GreaterThanEqualsToken || op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.LessThanEqualsToken || op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.InstanceOfKeyword || op === ts.SyntaxKind.InKeyword;
 const isOperationSyntax = (op) => op === ts.SyntaxKind.AsteriskToken || op === ts.SyntaxKind.SlashToken || op === ts.SyntaxKind.PercentToken || op === ts.SyntaxKind.AsteriskAsteriskToken || op === ts.SyntaxKind.MinusToken;
@@ -519,6 +533,7 @@ const canReturnWhenTrueInLogicalExpression = (op) => {
 function maybeBoxNode(node, stack, ctx, matchProp) {
 	const cache = (value) => {
 		cacheMap$1.set(node, value);
+		hasCachedEntries = true;
 		return value;
 	};
 	if (isCached(node)) return getCached(node);
@@ -915,17 +930,29 @@ const maybeDefinitionValue = (def, stack, ctx) => {
 		if (maybeValue) return maybeValue;
 	}
 };
-const getExportedVarDeclarationWithName = (varName, sourceFile, stack, ctx) => {
+const getExportedVarDeclarationWithName = (varName, sourceFile, stack, ctx, visited = /* @__PURE__ */ new Set()) => {
+	const key = `${sourceFile.getFilePath()}:${varName}`;
+	if (visited.has(key)) return;
+	visited.add(key);
 	const maybeVar = sourceFile.getVariableDeclaration(varName);
 	if (maybeVar) return maybeVar;
-	const exportDeclaration = resolveVarDeclarationFromExportWithName(varName, sourceFile, stack, ctx);
+	const exportDeclaration = resolveVarDeclarationFromExportWithName(varName, sourceFile, stack, ctx, visited);
 	if (!exportDeclaration) return;
 	return exportDeclaration;
 };
-const hasNamedExportWithName = (name, exportDeclaration) => {
+/**
+* Given the name a module exposes, the name to look for in the module it came from.
+* Returns `undefined` when this declaration does not provide `name` at all.
+*
+* For `export { btn as button } from './styles'` the two differ: `getAliasNode()`
+* is `button`, the name this module exports, and `getNameNode()` is `btn`, the name
+* to search for in `./styles`. Matching on the wrong one both hides names the
+* module does export and resolves names it does not.
+*/
+const resolveExportedName = (name, exportDeclaration) => {
 	const namedExports = exportDeclaration.getNamedExports();
-	if (namedExports.length === 0) return true;
-	for (const namedExport of namedExports) if (namedExport.getNameNode().getText() === name) return true;
+	if (namedExports.length === 0) return name;
+	for (const namedExport of namedExports) if ((namedExport.getAliasNode() ?? namedExport.getNameNode()).getText() === name) return namedExport.getNameNode().getText();
 };
 /**
 * Faster than declaration.getModuleSpecifierSourceFile()
@@ -945,14 +972,22 @@ const getModuleSpecifierSourceFile = (declaration) => {
 	if (!resolved.resolvedModule) return;
 	return project.addSourceFileAtPath(resolved.resolvedModule.resolvedFileName);
 };
-function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx) {
+function resolveVarDeclarationFromExportWithName(symbolName, sourceFile, stack, ctx, visited) {
 	for (const exportDeclaration of sourceFile.getExportDeclarations()) {
 		const exportStack = [exportDeclaration];
-		if (!hasNamedExportWithName(symbolName, exportDeclaration)) continue;
+		const sourceName = resolveExportedName(symbolName, exportDeclaration);
+		if (sourceName === void 0) continue;
 		const maybeFile = getModuleSpecifierSourceFile(exportDeclaration);
-		if (!maybeFile) continue;
+		if (!maybeFile) {
+			const localVar = sourceFile.getVariableDeclaration(sourceName);
+			if (localVar) {
+				stack.push(...exportStack.concat(localVar));
+				return localVar;
+			}
+			continue;
+		}
 		exportStack.push(maybeFile);
-		const maybeVar = getExportedVarDeclarationWithName(symbolName, maybeFile, stack, ctx);
+		const maybeVar = getExportedVarDeclarationWithName(sourceName, maybeFile, stack, ctx, visited);
 		if (maybeVar) {
 			stack.push(...exportStack.concat(maybeVar));
 			return maybeVar;
@@ -1811,4 +1846,4 @@ const unbox = (node, ctx) => {
 	return result;
 };
 //#endregion
-export { BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, box, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox };
+export { BoxNodeArray, BoxNodeConditional, BoxNodeEmptyInitializer, BoxNodeLiteral, BoxNodeMap, BoxNodeObject, BoxNodeUnresolvable, box, clearBoxNodeCache, extract, extractCallExpressionArguments, extractJsxAttribute, extractJsxElementProps, extractJsxSpreadAttributeValues, findIdentifierValueDeclaration, isBoxNode, maybeBoxNode, maybeIdentifierValue, unbox };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@bamboocss/extractor",
-  "version": "1.12.2",
+  "version": "1.13.1",
   "description": "The css extractor for css bamboo",
-  "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",
@@ -35,7 +35,7 @@
   "dependencies": {
     "ts-evaluator": "1.2.0",
     "ts-morph": "28.0.0",
-    "@bamboocss/shared": "1.12.2"
+    "@bamboocss/shared": "1.13.1"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format=cjs,esm --shims --dts",