@bamboocss/reporter 1.11.1 → 1.11.2

package/dist/index.cjs

@@ -0,0 +1,596 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let table = require("table");
+let wordwrapjs = require("wordwrapjs");
+wordwrapjs = __toESM(wordwrapjs);
+let _bamboocss_logger = require("@bamboocss/logger");
+let _bamboocss_shared = require("@bamboocss/shared");
+//#region ../../node_modules/.pnpm/markdown-table@3.0.4/node_modules/markdown-table/index.js
+/**
+* @typedef {Options} MarkdownTableOptions
+*   Configuration.
+*/
+/**
+* @typedef Options
+*   Configuration.
+* @property {boolean | null | undefined} [alignDelimiters=true]
+*   Whether to align the delimiters (default: `true`);
+*   they are aligned by default:
+*
+*   ```markdown
+*   | Alpha | B     |
+*   | ----- | ----- |
+*   | C     | Delta |
+*   ```
+*
+*   Pass `false` to make them staggered:
+*
+*   ```markdown
+*   | Alpha | B |
+*   | - | - |
+*   | C | Delta |
+*   ```
+* @property {ReadonlyArray<string | null | undefined> | string | null | undefined} [align]
+*   How to align columns (default: `''`);
+*   one style for all columns or styles for their respective columns;
+*   each style is either `'l'` (left), `'r'` (right), or `'c'` (center);
+*   other values are treated as `''`, which doesn’t place the colon in the
+*   alignment row but does align left;
+*   *only the lowercased first character is used, so `Right` is fine.*
+* @property {boolean | null | undefined} [delimiterEnd=true]
+*   Whether to end each row with the delimiter (default: `true`).
+*
+*   > 👉 **Note**: please don’t use this: it could create fragile structures
+*   > that aren’t understandable to some markdown parsers.
+*
+*   When `true`, there are ending delimiters:
+*
+*   ```markdown
+*   | Alpha | B     |
+*   | ----- | ----- |
+*   | C     | Delta |
+*   ```
+*
+*   When `false`, there are no ending delimiters:
+*
+*   ```markdown
+*   | Alpha | B
+*   | ----- | -----
+*   | C     | Delta
+*   ```
+* @property {boolean | null | undefined} [delimiterStart=true]
+*   Whether to begin each row with the delimiter (default: `true`).
+*
+*   > 👉 **Note**: please don’t use this: it could create fragile structures
+*   > that aren’t understandable to some markdown parsers.
+*
+*   When `true`, there are starting delimiters:
+*
+*   ```markdown
+*   | Alpha | B     |
+*   | ----- | ----- |
+*   | C     | Delta |
+*   ```
+*
+*   When `false`, there are no starting delimiters:
+*
+*   ```markdown
+*   Alpha | B     |
+*   ----- | ----- |
+*   C     | Delta |
+*   ```
+* @property {boolean | null | undefined} [padding=true]
+*   Whether to add a space of padding between delimiters and cells
+*   (default: `true`).
+*
+*   When `true`, there is padding:
+*
+*   ```markdown
+*   | Alpha | B     |
+*   | ----- | ----- |
+*   | C     | Delta |
+*   ```
+*
+*   When `false`, there is no padding:
+*
+*   ```markdown
+*   |Alpha|B    |
+*   |-----|-----|
+*   |C    |Delta|
+*   ```
+* @property {((value: string) => number) | null | undefined} [stringLength]
+*   Function to detect the length of table cell content (optional);
+*   this is used when aligning the delimiters (`|`) between table cells;
+*   full-width characters and emoji mess up delimiter alignment when viewing
+*   the markdown source;
+*   to fix this, you can pass this function,
+*   which receives the cell content and returns its “visible” size;
+*   note that what is and isn’t visible depends on where the text is displayed.
+*
+*   Without such a function, the following:
+*
+*   ```js
+*   markdownTable([
+*     ['Alpha', 'Bravo'],
+*     ['中文', 'Charlie'],
+*     ['👩‍❤️‍👩', 'Delta']
+*   ])
+*   ```
+*
+*   Yields:
+*
+*   ```markdown
+*   | Alpha | Bravo |
+*   | - | - |
+*   | 中文 | Charlie |
+*   | 👩‍❤️‍👩 | Delta |
+*   ```
+*
+*   With [`string-width`](https://github.com/sindresorhus/string-width):
+*
+*   ```js
+*   import stringWidth from 'string-width'
+*
+*   markdownTable(
+*     [
+*       ['Alpha', 'Bravo'],
+*       ['中文', 'Charlie'],
+*       ['👩‍❤️‍👩', 'Delta']
+*     ],
+*     {stringLength: stringWidth}
+*   )
+*   ```
+*
+*   Yields:
+*
+*   ```markdown
+*   | Alpha | Bravo   |
+*   | ----- | ------- |
+*   | 中文  | Charlie |
+*   | 👩‍❤️‍👩    | Delta   |
+*   ```
+*/
+/**
+* @param {string} value
+*   Cell value.
+* @returns {number}
+*   Cell size.
+*/
+function defaultStringLength(value) {
+	return value.length;
+}
+/**
+* Generate a markdown
+* ([GFM](https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/organizing-information-with-tables))
+* table.
+*
+* @param {ReadonlyArray<ReadonlyArray<string | null | undefined>>} table
+*   Table data (matrix of strings).
+* @param {Readonly<Options> | null | undefined} [options]
+*   Configuration (optional).
+* @returns {string}
+*   Result.
+*/
+function markdownTable(table, options) {
+	const settings = options || {};
+	const align = (settings.align || []).concat();
+	const stringLength = settings.stringLength || defaultStringLength;
+	/** @type {Array<number>} Character codes as symbols for alignment per column. */
+	const alignments = [];
+	/** @type {Array<Array<string>>} Cells per row. */
+	const cellMatrix = [];
+	/** @type {Array<Array<number>>} Sizes of each cell per row. */
+	const sizeMatrix = [];
+	/** @type {Array<number>} */
+	const longestCellByColumn = [];
+	let mostCellsPerRow = 0;
+	let rowIndex = -1;
+	while (++rowIndex < table.length) {
+		/** @type {Array<string>} */
+		const row = [];
+		/** @type {Array<number>} */
+		const sizes = [];
+		let columnIndex = -1;
+		if (table[rowIndex].length > mostCellsPerRow) mostCellsPerRow = table[rowIndex].length;
+		while (++columnIndex < table[rowIndex].length) {
+			const cell = serialize(table[rowIndex][columnIndex]);
+			if (settings.alignDelimiters !== false) {
+				const size = stringLength(cell);
+				sizes[columnIndex] = size;
+				if (longestCellByColumn[columnIndex] === void 0 || size > longestCellByColumn[columnIndex]) longestCellByColumn[columnIndex] = size;
+			}
+			row.push(cell);
+		}
+		cellMatrix[rowIndex] = row;
+		sizeMatrix[rowIndex] = sizes;
+	}
+	let columnIndex = -1;
+	if (typeof align === "object" && "length" in align) while (++columnIndex < mostCellsPerRow) alignments[columnIndex] = toAlignment(align[columnIndex]);
+	else {
+		const code = toAlignment(align);
+		while (++columnIndex < mostCellsPerRow) alignments[columnIndex] = code;
+	}
+	columnIndex = -1;
+	/** @type {Array<string>} */
+	const row = [];
+	/** @type {Array<number>} */
+	const sizes = [];
+	while (++columnIndex < mostCellsPerRow) {
+		const code = alignments[columnIndex];
+		let before = "";
+		let after = "";
+		if (code === 99) {
+			before = ":";
+			after = ":";
+		} else if (code === 108) before = ":";
+		else if (code === 114) after = ":";
+		let size = settings.alignDelimiters === false ? 1 : Math.max(1, longestCellByColumn[columnIndex] - before.length - after.length);
+		const cell = before + "-".repeat(size) + after;
+		if (settings.alignDelimiters !== false) {
+			size = before.length + size + after.length;
+			if (size > longestCellByColumn[columnIndex]) longestCellByColumn[columnIndex] = size;
+			sizes[columnIndex] = size;
+		}
+		row[columnIndex] = cell;
+	}
+	cellMatrix.splice(1, 0, row);
+	sizeMatrix.splice(1, 0, sizes);
+	rowIndex = -1;
+	/** @type {Array<string>} */
+	const lines = [];
+	while (++rowIndex < cellMatrix.length) {
+		const row = cellMatrix[rowIndex];
+		const sizes = sizeMatrix[rowIndex];
+		columnIndex = -1;
+		/** @type {Array<string>} */
+		const line = [];
+		while (++columnIndex < mostCellsPerRow) {
+			const cell = row[columnIndex] || "";
+			let before = "";
+			let after = "";
+			if (settings.alignDelimiters !== false) {
+				const size = longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0);
+				const code = alignments[columnIndex];
+				if (code === 114) before = " ".repeat(size);
+				else if (code === 99) if (size % 2) {
+					before = " ".repeat(size / 2 + .5);
+					after = " ".repeat(size / 2 - .5);
+				} else {
+					before = " ".repeat(size / 2);
+					after = before;
+				}
+				else after = " ".repeat(size);
+			}
+			if (settings.delimiterStart !== false && !columnIndex) line.push("|");
+			if (settings.padding !== false && !(settings.alignDelimiters === false && cell === "") && (settings.delimiterStart !== false || columnIndex)) line.push(" ");
+			if (settings.alignDelimiters !== false) line.push(before);
+			line.push(cell);
+			if (settings.alignDelimiters !== false) line.push(after);
+			if (settings.padding !== false) line.push(" ");
+			if (settings.delimiterEnd !== false || columnIndex !== mostCellsPerRow - 1) line.push("|");
+		}
+		lines.push(settings.delimiterEnd === false ? line.join("").replace(/ +$/, "") : line.join(""));
+	}
+	return lines.join("\n");
+}
+/**
+* @param {string | null | undefined} [value]
+*   Value to serialize.
+* @returns {string}
+*   Result.
+*/
+function serialize(value) {
+	return value === null || value === void 0 ? "" : String(value);
+}
+/**
+* @param {string | null | undefined} value
+*   Value.
+* @returns {number}
+*   Alignment.
+*/
+function toAlignment(value) {
+	const code = typeof value === "string" ? value.codePointAt(0) : 0;
+	return code === 67 || code === 99 ? 99 : code === 76 || code === 108 ? 108 : code === 82 || code === 114 ? 114 : 0;
+}
+//#endregion
+//#region src/report-format.ts
+const plural = (count, singular) => {
+	return `${count} ${new Intl.PluralRules("en-US").select(count) === "one" || count === 0 ? singular : `${singular}s`}`;
+};
+const createWrapFn = (enabled) => (str) => enabled ? wordwrapjs.default.wrap(str, { width: 20 }) : str;
+function formatTokenReport(result, format) {
+	const headers = [
+		"Token",
+		"Usage %",
+		"Most used",
+		"Hardcoded",
+		"Found in"
+	];
+	function getFormatted(entry, wrap) {
+		const wrapFn = createWrapFn(wrap);
+		return [
+			`${entry.category} (${plural(entry.count, "token")})`,
+			`${entry.percentUsed}% (${plural(entry.usedCount, "token")})`,
+			wrapFn(entry.mostUsedNames.join(", ")),
+			entry.hardcoded.toString(),
+			`${plural(entry.usedInXFiles, "file")}`
+		];
+	}
+	switch (format) {
+		case "json": return JSON.stringify(result, null, 2);
+		case "markdown": return markdownTable([headers, ...result.map((entry) => getFormatted(entry, true))]);
+		case "csv": return [headers.join(","), ...result.map((entry) => getFormatted(entry, false).join(","))].join("\n");
+		case "table": return (0, table.table)([headers, ...result.map((entry) => getFormatted(entry, true))]);
+		default: {
+			const formatted = result.map((entry) => getFormatted(entry, false));
+			return headers.map((header, index) => `${header}: ${formatted[index]}`).join("\n");
+		}
+	}
+}
+function formatRecipeReport(result, format) {
+	function getFormatted(entry, wrap) {
+		const wrapFn = createWrapFn(wrap);
+		return [
+			`${entry.recipeName} (${plural(entry.variantCount, "variant")})`,
+			`${plural(entry.possibleCombinations.length, "value")}`,
+			`${entry.percentUsed}% (${plural(entry.usedCombinations, "value")})`,
+			wrapFn(entry.mostUsedCombinations.join(", ")),
+			`${plural(entry.usedInXFiles, "file")}`,
+			`jsx: ${entry.jsxPercentUsed}%\nfn: ${entry.fnPercentUsed}%`
+		];
+	}
+	const headers = [
+		"Recipe",
+		"Variant values",
+		"Usage %",
+		"Most used",
+		"Found in",
+		"Used as"
+	];
+	switch (format) {
+		case "json": return JSON.stringify(result, null, 2);
+		case "markdown": return (0, table.table)([headers, ...result.map((entry) => getFormatted(entry, true))]);
+		case "csv": return [headers.join(","), ...result.map((entry) => getFormatted(entry, false).join(","))].join("\n");
+		case "table": return (0, table.table)([headers, ...result.map((entry) => getFormatted(entry, true))]);
+		default: {
+			const formatted = result.map((entry) => getFormatted(entry, false));
+			return headers.map((header, index) => `${header}: ${formatted[index]}`).join("\n");
+		}
+	}
+}
+//#endregion
+//#region package.json
+var version = "1.11.2";
+//#endregion
+//#region src/reporter-recipe.ts
+function analyzeRecipes(ctx, result) {
+	const recipesReportItems = Array.from(result.componentByIndex.values()).filter((reportItem) => reportItem.reportItemType === "recipe" || reportItem.reportItemType === "jsx-recipe");
+	const recipeReportMap = /* @__PURE__ */ new Map();
+	recipesReportItems.forEach((reportItem) => {
+		const recipeOrComponentName = reportItem.componentName;
+		const recipe = ctx.recipes.details.find((node) => node.match.test(recipeOrComponentName) || node.baseName === recipeOrComponentName);
+		if (!recipe) return;
+		const recipeName = recipe?.baseName;
+		if (!recipeReportMap.has(recipeName)) recipeReportMap.set(recipeName, /* @__PURE__ */ new Set());
+		recipeReportMap.get(recipeName).add(reportItem);
+	});
+	return Array.from(recipeReportMap.entries()).map(([recipeName, reportItems]) => [recipeName, Array.from(reportItems)]).map(([recipeName, reportItems]) => {
+		const usedCombinations = reportItems.map((component) => component.contains.map((id) => {
+			const reportItem = result.propByIndex.get(id);
+			if (!ctx.recipes.getRecipe(recipeName)?.variantKeys.includes(reportItem.propName)) return;
+			return reportItem.propName + "." + reportItem.value;
+		}).filter(Boolean)).flat();
+		const distinctUsedCombinations = Array.from(new Set(usedCombinations)).sort();
+		const usedCount = reportItems.length;
+		const recipe = ctx.recipes.getRecipe(recipeName);
+		const variantMap = recipe.variantKeyMap ?? {};
+		const possibleCombinations = Object.keys(variantMap).reduce((acc, variantName) => {
+			return acc.concat(variantMap[variantName].map((value) => `${variantName}.${value}`));
+		}, []);
+		const variantCount = recipe.variantKeys.length;
+		const percentUsed = Math.ceil(distinctUsedCombinations.length / (possibleCombinations.length || 1) * 1e4) / 100;
+		const jsxUsage = reportItems.filter((component) => component.reportItemType === "jsx-recipe");
+		const fnUsage = reportItems.filter((component) => component.reportItemType === "recipe");
+		const jsxPercentUsed = Math.ceil(jsxUsage.length / (reportItems.length || 1) * 100);
+		const fnPercentUsed = Math.ceil(fnUsage.length / (reportItems.length || 1) * 100);
+		return {
+			recipeName,
+			usedInXFiles: new Set(reportItems.flatMap((component) => component.filepath)).size,
+			usedCount,
+			variantCount,
+			possibleCombinations,
+			usedCombinations: distinctUsedCombinations.length,
+			percentUsed,
+			jsxPercentUsed,
+			fnPercentUsed,
+			unusedCombinations: possibleCombinations.length - distinctUsedCombinations.length,
+			mostUsedCombinations: distinctUsedCombinations.slice(0, 5)
+		};
+	}).sort((a, b) => b.percentUsed - a.percentUsed);
+}
+//#endregion
+//#region src/reporter-token.ts
+const formatter = new Intl.NumberFormat("en-US", {
+	maximumFractionDigits: 2,
+	minimumFractionDigits: 2
+});
+const getPercent = (used, total) => {
+	return Number(formatter.format(used / (total || 1) * 100));
+};
+function analyzeTokens(ctx, result) {
+	const categoryMap = result.derived.globalMaps.byTokenType;
+	const categoryEntries = Array.from(categoryMap.entries());
+	const usageMap = /* @__PURE__ */ new Map();
+	const totalMap = /* @__PURE__ */ new Map();
+	categoryEntries.forEach(([category, categoryIds]) => {
+		const usage = usageMap.get(category) || usageMap.set(category, []).get(category);
+		categoryIds.forEach((id) => {
+			const item = result.propByIndex.get(id);
+			if (item?.value == null) return;
+			const type = item.isKnownValue ? "token" : "nonToken";
+			const value = item.value.toString();
+			const filePath = item.filepath;
+			const loc = item.range ? {
+				line: item.range.startLineNumber,
+				column: item.range.startColumn
+			} : null;
+			usage.push({
+				category,
+				value,
+				filePath,
+				loc,
+				type
+			});
+		});
+		const totalTokens = ctx.tokens.view.categoryMap.get(category)?.size ?? 0;
+		totalMap.set(category, totalTokens);
+	});
+	const usageEntries = Array.from(usageMap.entries());
+	const percentMap = usageEntries.reduce((map, [category, usage]) => {
+		const total = totalMap.get(category) ?? 0;
+		const tokens = usage.reduce((acc, item) => {
+			return item.type === "token" ? acc.add(item.value) : acc;
+		}, /* @__PURE__ */ new Set());
+		const percent = getPercent(tokens.size, total);
+		return map.set(category, {
+			total,
+			used: tokens.size,
+			unused: total - tokens.size,
+			percent
+		});
+	}, /* @__PURE__ */ new Map());
+	const tokenNameMap = usageEntries.reduce((map, [category, usage]) => {
+		const existing = map.get(category) ?? [];
+		usage.forEach(({ value, type }) => {
+			if (type === "token") existing.push(value);
+		});
+		const sorted = (0, _bamboocss_shared.uniq)(existing).sort((a, b) => (result.derived.globalMaps.byTokenName.get(b)?.size ?? 0) - (result.derived.globalMaps.byTokenName.get(a)?.size ?? 0));
+		return map.set(category, sorted);
+	}, /* @__PURE__ */ new Map());
+	const fileUsageMap = usageEntries.reduce((map, [category, usage]) => {
+		const existing = map.get(category) ?? /* @__PURE__ */ new Set();
+		usage.forEach(({ filePath }) => {
+			if (filePath.startsWith("@config")) return;
+			existing.add(filePath);
+		});
+		return map.set(category, existing);
+	}, /* @__PURE__ */ new Map());
+	const hardcodedTokenMap = usageEntries.reduce((map, [category, usage]) => {
+		const items = /* @__PURE__ */ new Set();
+		usage.forEach(({ type, value }) => {
+			if (type === "nonToken") items.add(value);
+		});
+		return map.set(category, items.size);
+	}, /* @__PURE__ */ new Map());
+	return {
+		usageMap,
+		percentMap,
+		tokenNameMap,
+		fileUsageMap,
+		hardcodedTokenMap,
+		totalMap,
+		getSummary() {
+			return categoryEntries.map(([category]) => {
+				const percent = percentMap.get(category);
+				return {
+					category,
+					count: percent?.total ?? 0,
+					usedInXFiles: fileUsageMap.get(category)?.size ?? 0,
+					usedCount: percent?.used ?? 0,
+					percentUsed: percent?.percent ?? 0,
+					hardcoded: hardcodedTokenMap.get(category) ?? 0,
+					mostUsedNames: tokenNameMap.get(category)?.slice(0, 5) ?? []
+				};
+			}).sort((a, b) => b.percentUsed - a.percentUsed);
+		}
+	};
+}
+//#endregion
+//#region src/reporter.ts
+var Reporter = class {
+	ctx;
+	options;
+	#parserResults = /* @__PURE__ */ new Map();
+	#extractTimes = /* @__PURE__ */ new Map();
+	#sheet;
+	#report;
+	constructor(ctx, options) {
+		this.ctx = ctx;
+		this.options = options;
+	}
+	setup = () => {
+		this.#sheet = this.ctx.createSheet();
+		this.ctx.appendLayerParams(this.#sheet);
+		this.ctx.appendBaselineCss(this.#sheet);
+		this.parseFiles();
+		this.ctx.appendParserCss(this.#sheet);
+	};
+	get report() {
+		return this.#report;
+	}
+	parseFiles = () => {
+		const { getFiles } = this.options;
+		const files = getFiles();
+		_bamboocss_logger.logger.info("analyze", `Analyzing ${files.length} file(s) for token and recipe usage...`);
+		for (const file of files) this.parseFile(file);
+	};
+	parseFile = (file) => {
+		const { project, getRelativePath, onResult } = this.options;
+		const { config } = this.ctx;
+		const start = performance.now();
+		const result = project.parseSourceFile?.(file);
+		const extractMs = performance.now() - start;
+		const filePath = getRelativePath(config.cwd, file);
+		this.#extractTimes.set(filePath, extractMs);
+		_bamboocss_logger.logger.debug("analyze", `Parsed ${file} in ${extractMs}ms`);
+		if (result) {
+			this.#parserResults.set(filePath, result);
+			onResult?.(file, result);
+		}
+	};
+	init = () => {
+		const { project } = this.options;
+		this.setup();
+		const classify = project.classify(this.#parserResults);
+		this.#report = {
+			schemaVersion: version,
+			details: classify.details,
+			propByIndex: classify.propById,
+			componentByIndex: classify.componentById,
+			derived: classify.derived
+		};
+	};
+	getTokenReport = () => {
+		const { project } = this.options;
+		return analyzeTokens(project.parserOptions, this.#report);
+	};
+	getRecipeReport = () => {
+		const { project } = this.options;
+		return analyzeRecipes(project.parserOptions, this.#report);
+	};
+};
+//#endregion
+exports.Reporter = Reporter;
+exports.formatRecipeReport = formatRecipeReport;
+exports.formatTokenReport = formatTokenReport;

package/dist/index.d.cts

@@ -0,0 +1,85 @@
+import { ParserOptions } from "@bamboocss/core";
+import { AnalysisReport, ClassifyReport, Nullable, ParserResultInterface } from "@bamboocss/types";
+import { Generator } from "@bamboocss/generator";
+
+//#region src/reporter-recipe.d.ts
+interface RecipeReportEntry {
+  recipeName: string;
+  usedInXFiles: number;
+  usedCount: number;
+  variantCount: number;
+  usedCombinations: number;
+  percentUsed: number;
+  jsxPercentUsed: number;
+  fnPercentUsed: number;
+  possibleCombinations: string[];
+  unusedCombinations: number;
+  mostUsedCombinations: string[];
+}
+//#endregion
+//#region src/reporter-token.d.ts
+interface TokenUsageItem {
+  category: string;
+  value: string;
+  filePath: string;
+  type: 'token' | 'nonToken';
+  loc: Nullable<{
+    line: number;
+    column: number;
+  }>;
+}
+interface TokenReportEntry {
+  category: string;
+  usedInXFiles: number;
+  usedCount: number;
+  count: number;
+  percentUsed: number;
+  hardcoded: number;
+  mostUsedNames: string[];
+}
+interface TokenAnalysisReport {
+  usageMap: Map<string, TokenUsageItem[]>;
+  percentMap: Map<string, {
+    total: number;
+    used: number;
+    unused: number;
+    percent: number;
+  }>;
+  tokenNameMap: Map<string, string[]>;
+  fileUsageMap: Map<string, Set<string>>;
+  hardcodedTokenMap: Map<string, number>;
+  totalMap: Map<string, number>;
+  getSummary(): TokenReportEntry[];
+}
+//#endregion
+//#region src/report-format.d.ts
+type ReportFormat = 'json' | 'markdown' | 'csv' | 'text' | 'table';
+declare function formatTokenReport(result: TokenReportEntry[], format: ReportFormat): string;
+declare function formatRecipeReport(result: RecipeReportEntry[], format: ReportFormat): string;
+//#endregion
+//#region src/reporter.d.ts
+declare class Reporter {
+  #private;
+  private ctx;
+  private options;
+  constructor(ctx: Generator, options: ReporterOptions);
+  private setup;
+  get report(): AnalysisReport;
+  private parseFiles;
+  private parseFile;
+  init: () => void;
+  getTokenReport: () => TokenAnalysisReport;
+  getRecipeReport: () => RecipeReportEntry[];
+}
+interface ReporterOptions {
+  onResult?: (file: string, result: ParserResultInterface) => void;
+  project: {
+    parserOptions: ParserOptions;
+    parseSourceFile: (file: string) => ParserResultInterface | undefined;
+    classify: (fileMap: Map<string, ParserResultInterface>) => ClassifyReport;
+  };
+  getFiles: () => string[];
+  getRelativePath: (cwd: string, file: string) => string;
+}
+//#endregion
+export { type RecipeReportEntry, ReportFormat, Reporter, ReporterOptions, type TokenAnalysisReport, type TokenReportEntry, formatRecipeReport, formatTokenReport };