@bamboocss/parser 1.11.1 → 1.11.2

package/dist/index.cjs

@@ -0,0 +1,977 @@
+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 _bamboocss_logger = require("@bamboocss/logger");
+let ts_pattern = require("ts-pattern");
+let _bamboocss_config_ts_path = require("@bamboocss/config/ts-path");
+//#region src/classify.ts
+function addTo(map, key, value) {
+	const set = map.get(key) ?? /* @__PURE__ */ new Set();
+	set.add(value);
+	map.set(key, set);
+}
+function classifyProject(ctx, resultMap) {
+	const byId = /* @__PURE__ */ new Map();
+	const byComponentIndex = /* @__PURE__ */ new Map();
+	const byFilepath = /* @__PURE__ */ new Map();
+	const byComponentInFilepath = /* @__PURE__ */ new Map();
+	const globalMaps = createReportMaps();
+	const byFilePathMaps = /* @__PURE__ */ new Map();
+	const conditions = new Map(Object.entries(ctx.conditions.values));
+	const { groupByProp } = getPropertyGroupMap(ctx);
+	let id = 0;
+	let componentIndex = 0;
+	const isKnownUtility = (reportItem, componentReportItem) => {
+		const { propName, value, tokenType } = reportItem;
+		if (ctx.utility.config[propName]) {
+			if (ctx.tokens.getByName(`${tokenType}.${value}`)) return true;
+			if (ctx.tokens.getReferences(String(value)).length > 0) return true;
+			if (ctx.utility.resolveColorMix(String(value)).color) return true;
+			return false;
+		}
+		if (componentReportItem.reportItemType === "pattern") {
+			const patternProp = ctx.patterns.getConfig(componentReportItem.componentName.toLowerCase())?.properties?.[propName];
+			if (!patternProp) return false;
+			if (patternProp.type === "boolean" || patternProp.type === "number") return true;
+			if (patternProp.type === "property" && patternProp.value) return Boolean(ctx.utility.config[patternProp.value]);
+			if (patternProp.type === "enum" && patternProp.value) return Boolean(patternProp.value.includes(String(value)));
+			if (patternProp.type === "token") return Boolean(ctx.tokens.getByName(`${patternProp.value}.${value}`));
+			return false;
+		}
+		return false;
+	};
+	const processPattern = (opts) => {
+		const { boxNode, data, item, filepath, localMaps } = opts;
+		const name = item.componentName;
+		const pattern = ctx.patterns.details.find((p) => p.match.test(name) || p.baseName === name);
+		if (!pattern) return;
+		const cssObj = pattern.config.transform?.(data || {}, _bamboocss_shared.patternFns) ?? {};
+		const newItem = {
+			name: "css",
+			type: "css",
+			box: _bamboocss_extractor.box.objectToMap((0, _bamboocss_shared.compact)(cssObj), boxNode.getNode(), boxNode.getStack()),
+			data: [cssObj]
+		};
+		Object.assign(newItem, { debug: true });
+		return processResultItem({
+			item: newItem,
+			kind: "function",
+			localMaps,
+			filepath
+		});
+	};
+	const processResultItem = (opts) => {
+		const { item, kind, filepath, localMaps } = opts;
+		if (!item.box || _bamboocss_extractor.box.isUnresolvable(item.box)) return;
+		if (!item.data) return;
+		const componentReportItem = {
+			componentIndex: String(componentIndex++),
+			componentName: item.name,
+			reportItemType: item.type,
+			kind,
+			filepath,
+			value: item.data,
+			range: item.box.getRange(),
+			contains: [],
+			debug: Reflect.has(item, "debug")
+		};
+		if (item.type === "pattern" || item.type === "jsx-pattern") return processPattern({
+			boxNode: item.box,
+			data: item.data[0],
+			item: componentReportItem,
+			filepath,
+			localMaps
+		});
+		if (_bamboocss_extractor.box.isArray(item.box)) {
+			addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
+			return componentReportItem;
+		}
+		if (_bamboocss_extractor.box.isMap(item.box)) {
+			addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
+			processMap({
+				map: item.box,
+				current: [],
+				componentReportItem,
+				filepath,
+				localMaps
+			});
+			return componentReportItem;
+		}
+		if (item.type === "recipe") {
+			addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
+			return componentReportItem;
+		}
+	};
+	const processResultItemFn = (opts) => {
+		const { item, filepath, localMaps, type } = opts;
+		const componentReportItem = processResultItem({
+			item,
+			kind: type,
+			filepath,
+			localMaps
+		});
+		if (!componentReportItem) return;
+		addTo(globalMaps.byComponentOfKind, type, componentReportItem.componentIndex);
+		addTo(localMaps.byComponentOfKind, type, componentReportItem.componentIndex);
+		byComponentIndex.set(componentReportItem.componentIndex, componentReportItem);
+	};
+	const processMap = (opts) => {
+		const { map, current, componentReportItem, filepath, localMaps, skipRange } = opts;
+		const { reportItemType: type, kind, componentName: name } = componentReportItem;
+		map.value.forEach((attrNode, attrName) => {
+			if (_bamboocss_extractor.box.isLiteral(attrNode) || _bamboocss_extractor.box.isEmptyInitializer(attrNode)) {
+				const value = _bamboocss_extractor.box.isLiteral(attrNode) ? attrNode.value : true;
+				const propReportItem = {
+					index: String(id++),
+					componentIndex: String(componentReportItem.componentIndex),
+					componentName: name,
+					tokenType: void 0,
+					propName: attrName,
+					reportItemKind: "utility",
+					reportItemType: type,
+					kind,
+					filepath,
+					path: current.concat(attrName),
+					value,
+					isKnownValue: false,
+					range: skipRange ? null : map.getRange()
+				};
+				componentReportItem.contains.push(propReportItem.index);
+				if (conditions.has(attrName)) {
+					addTo(globalMaps.byConditionName, attrName, propReportItem.index);
+					addTo(localMaps.byConditionName, attrName, propReportItem.index);
+					propReportItem.propName = current[0] ?? attrName;
+					propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
+					propReportItem.conditionName = attrName;
+				} else {
+					if (current.length && conditions.has(current[0])) {
+						propReportItem.conditionName = current[0];
+						addTo(globalMaps.byConditionName, current[0], propReportItem.index);
+						addTo(localMaps.byConditionName, current[0], propReportItem.index);
+					}
+					const propName = ctx.utility.resolveShorthand(attrName);
+					const tokenType = ctx.utility.getTokenType(propName);
+					if (tokenType) {
+						propReportItem.reportItemKind = "token";
+						propReportItem.tokenType = tokenType;
+					}
+					propReportItem.propName = propName;
+					propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
+					addTo(globalMaps.byPropertyName, propName, propReportItem.index);
+					addTo(localMaps.byPropertyName, propName, propReportItem.index);
+					if (tokenType) {
+						addTo(globalMaps.byTokenType, tokenType, propReportItem.index);
+						addTo(localMaps.byTokenType, tokenType, propReportItem.index);
+					}
+					if (propName.toLowerCase().includes("color") || groupByProp.get(propName) === "Color" || tokenType === "colors") {
+						addTo(globalMaps.colorsUsed, value, propReportItem.index);
+						addTo(localMaps.colorsUsed, value, propReportItem.index);
+					}
+					if (ctx.utility.shorthands.has(attrName)) {
+						addTo(globalMaps.byShorthand, attrName, propReportItem.index);
+						addTo(localMaps.byShorthand, attrName, propReportItem.index);
+					}
+				}
+				if (current.length) {
+					addTo(globalMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
+					addTo(localMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
+				}
+				addTo(globalMaps.byTokenName, String(value), propReportItem.index);
+				addTo(localMaps.byTokenName, String(value), propReportItem.index);
+				addTo(globalMaps.byType, type, propReportItem.index);
+				addTo(localMaps.byType, type, propReportItem.index);
+				addTo(globalMaps.byComponentName, name, propReportItem.index);
+				addTo(localMaps.byComponentName, name, propReportItem.index);
+				addTo(globalMaps.fromKind, kind, propReportItem.index);
+				addTo(localMaps.fromKind, kind, propReportItem.index);
+				addTo(byFilepath, filepath, propReportItem.index);
+				byId.set(propReportItem.index, propReportItem);
+				return;
+			}
+			if (_bamboocss_extractor.box.isMap(attrNode) && attrNode.value.size) return processMap({
+				map: attrNode,
+				current: current.concat(attrName),
+				componentReportItem,
+				filepath,
+				localMaps
+			});
+		});
+	};
+	resultMap.forEach((parserResult, filepath) => {
+		if (parserResult.isEmpty()) return;
+		const localMaps = createReportMaps();
+		const componentFn = (item) => {
+			processResultItemFn({
+				item,
+				filepath,
+				localMaps,
+				type: "component"
+			});
+		};
+		const functionFn = (item) => {
+			processResultItemFn({
+				item,
+				filepath,
+				localMaps,
+				type: "function"
+			});
+		};
+		parserResult.jsx.forEach(componentFn);
+		parserResult.css.forEach(functionFn);
+		parserResult.cva.forEach(functionFn);
+		parserResult.pattern.forEach((itemList) => {
+			itemList.forEach(functionFn);
+		});
+		parserResult.recipe.forEach((itemList) => {
+			itemList.forEach(functionFn);
+		});
+		byFilePathMaps.set(filepath, localMaps);
+	});
+	const filesWithMostComponent = Object.fromEntries(Array.from(byComponentInFilepath.entries()).map(([filepath, list]) => [filepath, list.size]).sort((a, b) => b[1] - a[1]).slice(0, 10));
+	Object.entries(ctx.recipes.config).forEach(([key, recipe]) => {
+		const localMaps = createReportMaps();
+		const functionFn = (styleObject) => {
+			if (!styleObject) return;
+			const componentReportItem = {
+				componentIndex: "0",
+				componentName: `recipes.${key}.base`,
+				reportItemType: "css",
+				kind: "function",
+				filepath: `theme/recipes/${key}`,
+				value: styleObject,
+				range: null,
+				contains: []
+			};
+			processMap({
+				map: _bamboocss_extractor.box.objectToMap(styleObject, null, []),
+				current: [],
+				filepath: `@config/theme/recipes/${key}`,
+				skipRange: true,
+				localMaps,
+				componentReportItem
+			});
+		};
+		const isSlotRecipe = (_v) => ctx.recipes.isSlotRecipe(key);
+		if (isSlotRecipe(recipe)) {
+			Object.values(recipe.base ?? {}).forEach(functionFn);
+			Object.values(recipe.variants ?? {}).forEach((variants) => {
+				Object.values(variants).forEach((v) => {
+					Object.values(v).forEach(functionFn);
+				});
+			});
+			recipe.compoundVariants?.forEach((v) => {
+				Object.values(v.css).forEach(functionFn);
+			});
+		} else {
+			functionFn(recipe.base);
+			Object.values(recipe.variants ?? {}).forEach((variants) => {
+				Object.values(variants).forEach(functionFn);
+			});
+			recipe.compoundVariants?.forEach((v) => functionFn(v.css));
+		}
+	});
+	Object.values(ctx.config.globalCss ?? {}).forEach((styleObject) => {
+		if (!styleObject) return;
+		processMap({
+			map: _bamboocss_extractor.box.objectToMap(styleObject, null, []),
+			current: [],
+			filepath: "@config/globalCss",
+			skipRange: true,
+			localMaps: createReportMaps(),
+			componentReportItem: {
+				componentIndex: "0",
+				componentName: "global",
+				reportItemType: "css",
+				kind: "function",
+				filepath: "global",
+				value: styleObject,
+				range: null,
+				contains: []
+			}
+		});
+	});
+	return {
+		propById: byId,
+		componentById: byComponentIndex,
+		details: {
+			counts: {
+				filesWithTokens: byFilepath.size,
+				propNameUsed: globalMaps.byPropertyName.size,
+				tokenUsed: globalMaps.byTokenName.size,
+				shorthandUsed: globalMaps.byShorthand.size,
+				propertyPathUsed: globalMaps.byPropertyPath.size,
+				typeUsed: globalMaps.byType.size,
+				componentNameUsed: globalMaps.byComponentName.size,
+				kindUsed: globalMaps.fromKind.size,
+				componentOfKindUsed: globalMaps.byComponentOfKind.size,
+				colorsUsed: globalMaps.colorsUsed.size
+			},
+			stats: {
+				filesWithMostComponent,
+				mostUseds: getXMostUseds(globalMaps, 10)
+			}
+		},
+		derived: {
+			byFilepath,
+			byComponentInFilepath,
+			globalMaps,
+			byFilePathMaps
+		}
+	};
+}
+const getXMostUseds = (globalMaps, pickCount) => {
+	return {
+		propNames: getMostUsedInMap(globalMaps.byPropertyName, pickCount),
+		tokens: getMostUsedInMap(globalMaps.byTokenName, pickCount),
+		shorthands: getMostUsedInMap(globalMaps.byShorthand, pickCount),
+		conditions: getMostUsedInMap(globalMaps.byConditionName, pickCount),
+		propertyPaths: getMostUsedInMap(globalMaps.byPropertyPath, pickCount),
+		categories: getMostUsedInMap(globalMaps.byTokenType, pickCount),
+		types: getMostUsedInMap(globalMaps.byType, pickCount),
+		componentNames: getMostUsedInMap(globalMaps.byComponentName, pickCount),
+		fromKinds: getMostUsedInMap(globalMaps.fromKind, pickCount),
+		componentOfKinds: getMostUsedInMap(globalMaps.byComponentOfKind, pickCount),
+		colors: getMostUsedInMap(globalMaps.colorsUsed, pickCount)
+	};
+};
+const getMostUsedInMap = (map, pickCount) => {
+	return Array.from(map.entries()).map(([key, list]) => [key, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount).map(([key, count]) => ({
+		key,
+		count
+	}));
+};
+const defaultGroupNames = [
+	"System",
+	"Container",
+	"Display",
+	"Visibility",
+	"Position",
+	"Transform",
+	"Flex Layout",
+	"Grid Layout",
+	"Layout",
+	"Border",
+	"Border Radius",
+	"Width",
+	"Height",
+	"Margin",
+	"Padding",
+	"Color",
+	"Typography",
+	"Background",
+	"Shadow",
+	"Table",
+	"List",
+	"Scroll",
+	"Interactivity",
+	"Transition",
+	"Effect",
+	"Other",
+	"Focus Ring"
+];
+function getPropertyGroupMap(ctx) {
+	const groups = new Map(defaultGroupNames.map((name) => [name, /* @__PURE__ */ new Set()]));
+	const groupByProp = /* @__PURE__ */ new Map();
+	const systemGroup = groups.get("System");
+	systemGroup.add("base");
+	systemGroup.add("colorPalette");
+	const otherStyleProps = groups.get("Other");
+	Object.entries(ctx.utility.config).map(([key, value]) => {
+		const group = value?.group;
+		if (!group) {
+			otherStyleProps.add(key);
+			return;
+		}
+		if (!groups.has(group)) groups.set(group, /* @__PURE__ */ new Set());
+		const set = groups.get(group);
+		if (value.shorthand) if (Array.isArray(value.shorthand)) value.shorthand.forEach((shorthand) => {
+			set.add(shorthand);
+			groupByProp.set(shorthand, group);
+		});
+		else {
+			set.add(value.shorthand);
+			groupByProp.set(value.shorthand, group);
+		}
+		set.add(key);
+		groupByProp.set(key, group);
+	});
+	return {
+		groups,
+		groupByProp
+	};
+}
+function createReportMaps() {
+	return {
+		byComponentOfKind: /* @__PURE__ */ new Map(),
+		byPropertyName: /* @__PURE__ */ new Map(),
+		byTokenType: /* @__PURE__ */ new Map(),
+		byConditionName: /* @__PURE__ */ new Map(),
+		byShorthand: /* @__PURE__ */ new Map(),
+		byTokenName: /* @__PURE__ */ new Map(),
+		byPropertyPath: /* @__PURE__ */ new Map(),
+		fromKind: /* @__PURE__ */ new Map(),
+		byType: /* @__PURE__ */ new Map(),
+		byComponentName: /* @__PURE__ */ new Map(),
+		colorsUsed: /* @__PURE__ */ new Map()
+	};
+}
+//#endregion
+//#region src/get-module-specifier-value.ts
+const getModuleSpecifierValue = (node) => {
+	try {
+		return node.getModuleSpecifierValue();
+	} catch {
+		return;
+	}
+};
+//#endregion
+//#region src/get-import-declarations.ts
+function getImportDeclarations(context, sourceFile) {
+	const { imports, tsOptions } = context;
+	const importDeclarations = [];
+	sourceFile.getImportDeclarations().forEach((node) => {
+		const mod = getModuleSpecifierValue(node);
+		if (!mod) return;
+		node.getNamedImports().forEach((specifier) => {
+			const name = specifier.getNameNode().getText();
+			const result = {
+				name,
+				alias: specifier.getAliasNode()?.getText() || name,
+				mod,
+				kind: "named"
+			};
+			if (!imports.match(result, (mod) => {
+				if (!tsOptions?.pathMappings) return;
+				return (0, _bamboocss_config_ts_path.resolveTsPathPattern)(tsOptions.pathMappings, mod);
+			})) return;
+			importDeclarations.push(result);
+		});
+		const namespace = node.getNamespaceImport();
+		if (namespace) {
+			const name = namespace.getText();
+			const result = {
+				name,
+				alias: name,
+				mod,
+				kind: "namespace"
+			};
+			if (!imports.match(result, (mod) => {
+				if (!tsOptions?.pathMappings) return;
+				return (0, _bamboocss_config_ts_path.resolveTsPathPattern)(tsOptions.pathMappings, mod);
+			})) return;
+			importDeclarations.push(result);
+		}
+	});
+	return importDeclarations;
+}
+//#endregion
+//#region src/parser-result.ts
+function cartesian(arrays) {
+	if (arrays.length === 0) return [[]];
+	const [first, ...rest] = arrays;
+	const restProduct = cartesian(rest);
+	return first.flatMap((item) => restProduct.map((combo) => [item, ...combo]));
+}
+var ParserResult = class {
+	context;
+	/** Ordered list of all ResultItem */
+	all = [];
+	jsx = /* @__PURE__ */ new Set();
+	css = /* @__PURE__ */ new Set();
+	cva = /* @__PURE__ */ new Set();
+	sva = /* @__PURE__ */ new Set();
+	token = /* @__PURE__ */ new Set();
+	recipe = /* @__PURE__ */ new Map();
+	pattern = /* @__PURE__ */ new Map();
+	filePath;
+	encoder;
+	constructor(context, encoder) {
+		this.context = context;
+		this.encoder = encoder ?? context.encoder;
+	}
+	append(result) {
+		this.all.push(result);
+		return result;
+	}
+	set(name, result) {
+		switch (name) {
+			case "css":
+				this.setCss(result);
+				break;
+			case "cva":
+				this.setCva(result);
+				break;
+			case "sva":
+				this.setSva(result);
+				break;
+			case "token":
+				this.setToken(result);
+				break;
+			default: throw new _bamboocss_shared.BambooError("UNKNOWN_RESULT_TYPE", `Unknown parser result type: "${name}". Expected one of: css, cva, sva, token`);
+		}
+	}
+	setCss(result) {
+		this.css.add(this.append(Object.assign({ type: "css" }, result)));
+		const encoder = this.encoder;
+		const grouped = this.context.config.cssMode === "grouped";
+		if (!grouped || result.data.length <= 1) {
+			result.data.forEach((obj) => grouped ? encoder.processGrouped(obj) : encoder.processAtomic(obj));
+			return;
+		}
+		const keyCounts = /* @__PURE__ */ new Map();
+		for (const obj of result.data) for (const key of Object.keys(obj)) keyCounts.set(key, (keyCounts.get(key) || 0) + 1);
+		if (!Array.from(keyCounts.values()).some((c) => c > 1)) {
+			encoder.processGrouped(Object.assign({}, ...result.data));
+			return;
+		}
+		const overlappingKeys = /* @__PURE__ */ new Set();
+		keyCounts.forEach((count, key) => {
+			if (count > 1) overlappingKeys.add(key);
+		});
+		const base = {};
+		const branchEntries = [];
+		for (const obj of result.data) if (Object.keys(obj).some((k) => overlappingKeys.has(k))) branchEntries.push(obj);
+		else Object.assign(base, obj);
+		const branchGroups = /* @__PURE__ */ new Map();
+		for (const entry of branchEntries) {
+			const keySet = Object.keys(entry).sort().join("\0");
+			const group = branchGroups.get(keySet) || [];
+			group.push(entry);
+			branchGroups.set(keySet, group);
+		}
+		const groupArrays = Array.from(branchGroups.values());
+		if (groupArrays.reduce((acc, g) => acc * g.length, 1) > 32) {
+			result.data.forEach((obj) => encoder.processGrouped(obj));
+			return;
+		}
+		for (const combo of cartesian(groupArrays)) encoder.processGrouped(Object.assign({}, base, ...combo));
+	}
+	setCva(result) {
+		this.cva.add(this.append(Object.assign({ type: "cva" }, result)));
+		const encoder = this.encoder;
+		result.data.forEach((data) => encoder.processAtomicRecipe(data));
+	}
+	setSva(result) {
+		this.sva.add(this.append(Object.assign({ type: "sva" }, result)));
+		const encoder = this.encoder;
+		result.data.forEach((data) => encoder.processAtomicSlotRecipe(data));
+	}
+	setToken(result) {
+		this.token.add(this.append(Object.assign({ type: "token" }, result)));
+	}
+	setJsx(result) {
+		this.jsx.add(this.append(Object.assign({ type: "jsx" }, result)));
+		const encoder = this.encoder;
+		const grouped = this.context.config.cssMode === "grouped";
+		result.data.forEach((obj) => encoder.processStyleProps(obj, grouped));
+	}
+	setPattern(name, result) {
+		(0, _bamboocss_shared.getOrCreateSet)(this.pattern, name).add(this.append(Object.assign({
+			type: "pattern",
+			name
+		}, result)));
+		const encoder = this.encoder;
+		result.data.forEach((obj) => encoder.processPattern(name, obj, result.type ?? "pattern", result.name));
+	}
+	setRecipe(recipeName, result) {
+		(0, _bamboocss_shared.getOrCreateSet)(this.recipe, recipeName).add(this.append(Object.assign({ type: "recipe" }, result)));
+		const encoder = this.encoder;
+		const recipes = this.context.recipes;
+		if (!recipes.getConfig(recipeName)) return;
+		const recipe = result;
+		if (result.type) recipe.data.forEach((data) => {
+			const [recipeProps, styleProps] = recipes.splitProps(recipeName, data);
+			encoder.processStyleProps(styleProps);
+			encoder.processRecipe(recipeName, recipeProps);
+		});
+		else recipe.data.forEach((data) => {
+			encoder.processRecipe(recipeName, data);
+		});
+	}
+	isEmpty() {
+		return this.all.length === 0;
+	}
+	setFilePath(filePath) {
+		this.filePath = filePath;
+		return this;
+	}
+	merge(result) {
+		result.css.forEach((item) => this.css.add(this.append(item)));
+		result.cva.forEach((item) => this.cva.add(this.append(item)));
+		result.sva.forEach((item) => this.sva.add(this.append(item)));
+		result.token.forEach((item) => this.token.add(this.append(item)));
+		result.jsx.forEach((item) => this.jsx.add(this.append(item)));
+		result.recipe.forEach((items, name) => {
+			const set = (0, _bamboocss_shared.getOrCreateSet)(this.recipe, name);
+			items.forEach((item) => set.add(this.append(item)));
+		});
+		result.pattern.forEach((items, name) => {
+			const set = (0, _bamboocss_shared.getOrCreateSet)(this.pattern, name);
+			items.forEach((item) => set.add(this.append(item)));
+		});
+		return this;
+	}
+	toArray() {
+		return this.all;
+	}
+	toJSON() {
+		return {
+			css: Array.from(this.css),
+			cva: Array.from(this.cva),
+			sva: Array.from(this.sva),
+			token: Array.from(this.token),
+			jsx: Array.from(this.jsx),
+			recipe: Object.fromEntries(Array.from(this.recipe.entries()).map(([key, value]) => [key, Array.from(value)])),
+			pattern: Object.fromEntries(Array.from(this.pattern.entries()).map(([key, value]) => [key, Array.from(value)]))
+		};
+	}
+};
+//#endregion
+//#region src/parser.ts
+const combineResult = (unboxed) => {
+	return [
+		...unboxed.conditions,
+		unboxed.raw,
+		...unboxed.spreadConditions
+	];
+};
+const defaultEnv = { preset: "ECMA" };
+const evaluateOptions = { environment: defaultEnv };
+function createParser(context) {
+	const { jsx, imports, recipes, config } = context;
+	const syntax = config.syntax;
+	return function parse(sourceFile, encoder, options) {
+		if (!sourceFile) return;
+		const importDeclarations = getImportDeclarations(context, sourceFile);
+		const file = imports.file(importDeclarations);
+		const filePath = sourceFile.getFilePath();
+		_bamboocss_logger.logger.debug("ast:import", !file.isEmpty() ? `Found import { ${file.toString()} } in ${filePath}` : `No import found in ${filePath}`);
+		const parserResult = new ParserResult(context, encoder);
+		if (file.isEmpty() && !jsx.isEnabled) return parserResult;
+		(0, _bamboocss_extractor.extract)({
+			ast: sourceFile,
+			tokens: context.tokens ? {
+				view: context.tokens.view,
+				isTokenFn: (fnName) => file.isTokenAlias(fnName)
+			} : void 0,
+			components: jsx.isEnabled ? {
+				matchTag: (prop) => {
+					if (options?.matchTag) {
+						const isBambooComponent = file.isBambooComponent(prop.tagName);
+						const matchTagMode = options.matchTagMode ?? "extend";
+						const isCustomMatch = options.matchTag(prop.tagName, isBambooComponent);
+						if (matchTagMode === "override") return isCustomMatch;
+						return isBambooComponent || isCustomMatch;
+					}
+					return !!file.matchTag(prop.tagName);
+				},
+				matchProp: (prop) => {
+					const isBambooProp = file.matchTagProp(prop.tagName, prop.propName);
+					if (options?.matchTagProp) return isBambooProp && options.matchTagProp(prop.tagName, prop.propName);
+					return isBambooProp;
+				}
+			} : void 0,
+			functions: {
+				matchFn: (prop) => file.matchFn(prop.fnName),
+				matchProp: () => true,
+				matchArg: (prop) => {
+					if (file.isJsxFactory(prop.fnName) && prop.index === 1 && ts_morph.Node.isIdentifier(prop.argNode)) return false;
+					return true;
+				}
+			},
+			taggedTemplates: syntax === "template-literal" ? { matchTaggedTemplate: (tag) => file.matchFn(tag.fnName) } : void 0,
+			getEvaluateOptions: (node) => {
+				if (!ts_morph.Node.isCallExpression(node)) return evaluateOptions;
+				const propAccessExpr = node.getExpression();
+				if (!ts_morph.Node.isPropertyAccessExpression(propAccessExpr)) return evaluateOptions;
+				let name = propAccessExpr.getText();
+				if (!file.isRawFn(name)) return evaluateOptions;
+				name = name.replace(".raw", "");
+				return { environment: Object.assign({}, defaultEnv, { extra: { [name]: { raw: (v) => v } } }) };
+			},
+			flags: { skipTraverseFiles: true }
+		}).forEach((result, alias) => {
+			const name = file.getName(file.normalizeFnName(alias));
+			_bamboocss_logger.logger.debug(`ast:${name}`, name !== alias ? {
+				kind: result.kind,
+				alias
+			} : { kind: result.kind });
+			if (result.kind === "function") (0, ts_pattern.match)(name).when(imports.matchers.css.match, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") if (query.box.value.length > 1) parserResult.set(name, {
+						name,
+						box: query.box,
+						data: query.box.value.reduce((acc, value) => [...acc, ...combineResult((0, _bamboocss_extractor.unbox)(value))], [])
+					});
+					else parserResult.set(name, {
+						name,
+						box: query.box.value[0] ?? _bamboocss_extractor.box.fallback(query.box),
+						data: combineResult((0, _bamboocss_extractor.unbox)(query.box.value[0]))
+					});
+					else if (query.kind === "tagged-template") {
+						const obj = (0, _bamboocss_shared.astish)(query.box.value);
+						parserResult.set(name, {
+							name,
+							box: query.box ?? _bamboocss_extractor.box.fallback(query.box),
+							data: [obj]
+						});
+					}
+				});
+			}).when(imports.matchers.tokens.match, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") parserResult.setToken({
+						name,
+						box: query.box.value[0] ?? _bamboocss_extractor.box.fallback(query.box),
+						data: combineResult((0, _bamboocss_extractor.unbox)(query.box.value[0]))
+					});
+				});
+			}).when(file.isValidPattern, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") parserResult.setPattern(name, {
+						name,
+						box: query.box.value[0] ?? _bamboocss_extractor.box.fallback(query.box),
+						data: combineResult((0, _bamboocss_extractor.unbox)(query.box.value[0]))
+					});
+				});
+			}).when(file.isValidRecipe, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") parserResult.setRecipe(name, {
+						name,
+						box: query.box.value[0] ?? _bamboocss_extractor.box.fallback(query.box),
+						data: combineResult((0, _bamboocss_extractor.unbox)(query.box.value[0]))
+					});
+				});
+			}).when(jsx.isJsxFactory, () => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression" && query.box.value[1]) {
+						const map = query.box.value[1];
+						const boxNode = _bamboocss_extractor.box.isMap(map) ? map : _bamboocss_extractor.box.fallback(query.box);
+						const combined = combineResult((0, _bamboocss_extractor.unbox)(boxNode));
+						const result = {
+							name,
+							box: boxNode,
+							data: options?.transform?.({
+								type: "jsx-factory",
+								data: combined
+							}) ?? combined
+						};
+						if (_bamboocss_extractor.box.isRecipe(map)) parserResult.setCva(result);
+						else parserResult.set("css", result);
+						const recipeOptions = query.box.value[2];
+						if (_bamboocss_extractor.box.isUnresolvable(map) && recipeOptions && _bamboocss_extractor.box.isMap(recipeOptions) && recipeOptions.value.has("defaultProps")) {
+							const maybeIdentifier = map.getNode();
+							if (ts_morph.Node.isIdentifier(maybeIdentifier)) {
+								const name = maybeIdentifier.getText();
+								const recipeName = file.getName(name);
+								parserResult.setRecipe(recipeName, {
+									type: "jsx-recipe",
+									name: recipeName,
+									box: recipeOptions,
+									data: combineResult((0, _bamboocss_extractor.unbox)(recipeOptions.value.get("defaultProps")))
+								});
+							}
+						}
+					} else if (query.kind === "tagged-template") {
+						const obj = (0, _bamboocss_shared.astish)(query.box.value);
+						parserResult.set("css", {
+							name,
+							box: query.box ?? _bamboocss_extractor.box.fallback(query.box),
+							data: [obj]
+						});
+					}
+				});
+			}).when(file.isJsxFactory, (name) => {
+				result.queryList.forEach((query) => {
+					if (query.kind === "call-expression") {
+						const map = query.box.value[0];
+						const boxNode = _bamboocss_extractor.box.isMap(map) ? map : _bamboocss_extractor.box.fallback(query.box);
+						const combined = combineResult((0, _bamboocss_extractor.unbox)(boxNode));
+						const result = {
+							name,
+							box: boxNode,
+							data: options?.transform?.({
+								type: "jsx-factory",
+								data: combined
+							}) ?? combined
+						};
+						if (_bamboocss_extractor.box.isRecipe(map)) parserResult.setCva(result);
+						else parserResult.set("css", result);
+					} else if (query.kind === "tagged-template") {
+						const obj = (0, _bamboocss_shared.astish)(query.box.value);
+						parserResult.set("css", {
+							name,
+							box: query.box ?? _bamboocss_extractor.box.fallback(query.box),
+							data: [obj]
+						});
+					}
+				});
+			}).otherwise(() => {});
+			else if (jsx.isEnabled && result.kind === "component") result.queryList.forEach((query) => {
+				const data = combineResult((0, _bamboocss_extractor.unbox)(query.box));
+				switch (true) {
+					case file.isJsxFactory(name) || file.isJsxFactory(alias):
+						parserResult.setJsx({
+							type: "jsx-factory",
+							name,
+							box: query.box,
+							data
+						});
+						break;
+					case jsx.isJsxTagPattern(name) || jsx.isJsxTagPattern(alias):
+						parserResult.setPattern(name, {
+							type: "jsx-pattern",
+							name,
+							box: query.box,
+							data
+						});
+						break;
+					case jsx.isJsxTagRecipe(name):
+						recipes.filter(name).map((recipe) => {
+							parserResult.setRecipe(recipe.baseName, {
+								type: "jsx-recipe",
+								name,
+								box: query.box,
+								data
+							});
+						});
+						break;
+					case jsx.isJsxTagRecipe(alias):
+						recipes.filter(alias).map((recipe) => {
+							parserResult.setRecipe(recipe.baseName, {
+								type: "jsx-recipe",
+								name: alias,
+								box: query.box,
+								data
+							});
+						});
+						break;
+					default: parserResult.setJsx({
+						type: "jsx",
+						name,
+						box: query.box,
+						data
+					});
+				}
+			});
+		});
+		return parserResult;
+	};
+}
+//#endregion
+//#region src/project.ts
+const normalizeCompilerOptions = (raw) => {
+	if (!raw) return {};
+	const { options } = ts_morph.ts.convertCompilerOptionsFromJson(raw, process.cwd());
+	return options;
+};
+const createTsProject = (options) => new ts_morph.Project({
+	skipAddingFilesFromTsConfig: true,
+	skipFileDependencyResolution: true,
+	skipLoadingLibFiles: true,
+	...options,
+	compilerOptions: {
+		allowJs: true,
+		strictNullChecks: false,
+		skipLibCheck: true,
+		...normalizeCompilerOptions(options.compilerOptions)
+	}
+});
+var Project = class {
+	options;
+	project;
+	parser;
+	get parserOptions() {
+		return this.options.parserOptions;
+	}
+	constructor(options) {
+		this.options = options;
+		const { parserOptions } = options;
+		this.project = createTsProject(options);
+		this.parser = createParser(parserOptions);
+		this.createSourceFiles();
+	}
+	get files() {
+		return this.options.getFiles();
+	}
+	getSourceFile = (filePath) => {
+		return this.project.getSourceFile(filePath);
+	};
+	createSourceFile = (filePath) => {
+		const { readFile } = this.options;
+		return this.project.createSourceFile(filePath, readFile(filePath), {
+			overwrite: true,
+			scriptKind: ts_morph.ScriptKind.TSX
+		});
+	};
+	createSourceFiles = () => {
+		const files = this.getFiles();
+		for (const file of files) this.createSourceFile(file);
+	};
+	addSourceFile = (filePath, content) => {
+		return this.project.createSourceFile(filePath, content, {
+			overwrite: true,
+			scriptKind: ts_morph.ScriptKind.TSX
+		});
+	};
+	removeSourceFile = (filePath) => {
+		const sourceFile = this.project.getSourceFile(filePath);
+		if (sourceFile) return this.project.removeSourceFile(sourceFile);
+		return false;
+	};
+	reloadSourceFile = (filePath) => {
+		return this.getSourceFile(filePath)?.refreshFromFileSystemSync();
+	};
+	reloadSourceFiles = () => {
+		const files = this.getFiles();
+		for (const file of files) this.getSourceFile(file)?.refreshFromFileSystemSync() ?? this.project.addSourceFileAtPath(file);
+	};
+	get readFile() {
+		return this.options.readFile;
+	}
+	get getFiles() {
+		return this.options.getFiles;
+	}
+	parseJson = (filePath) => {
+		const { readFile, parserOptions } = this.options;
+		const content = readFile(filePath);
+		parserOptions.encoder.fromJSON(JSON.parse(content));
+		return new ParserResult(parserOptions).setFilePath(filePath);
+	};
+	parseSourceFile = (filePath, encoder) => {
+		const { hooks } = this.options;
+		if (filePath.endsWith(".json")) return this.parseJson(filePath);
+		const sourceFile = this.project.getSourceFile(filePath);
+		if (!sourceFile) return;
+		const original = sourceFile.getText();
+		const options = {};
+		const transformed = hooks["parser:before"]?.({
+			filePath,
+			content: original,
+			configure(opts) {
+				const { matchTag, matchTagMode, matchTagProp } = opts;
+				if (matchTag) options.matchTag = matchTag;
+				if (matchTagMode) options.matchTagMode = matchTagMode;
+				if (matchTagProp) options.matchTagProp = matchTagProp;
+			}
+		}) ?? this.transformFile(filePath, original);
+		if (original !== transformed) sourceFile.replaceWithText(transformed);
+		if (hooks["parser:preprocess"]) options.transform = hooks["parser:preprocess"];
+		const result = this.parser(sourceFile, encoder, options)?.setFilePath(filePath);
+		hooks["parser:after"]?.({
+			filePath,
+			result
+		});
+		return result;
+	};
+	transformFile = (_filePath, content) => {
+		return content;
+	};
+	classify = (fileMap) => {
+		const { parserOptions } = this.options;
+		return classifyProject(parserOptions, fileMap);
+	};
+};
+//#endregion
+exports.ParserResult = ParserResult;
+exports.Project = Project;