@codefast/cli 0.3.12 → 0.3.13-canary.1

package/dist/lib/arrange/application/group-file.mjs

@@ -0,0 +1,113 @@
+import { applyEditsDescending, buildKnownCnTvBindings, lineOf, unwrapCnInsideTvCallReplacement } from "../domain/ast/ast-helpers.mjs";
+import { listAllCnCallsInsideTvInSourceFile } from "../domain/ast/collectors-tv.mjs";
+import { collectGroupTargets, planGroupEditForTarget, targetReplaceStart } from "../domain/ast/targets.mjs";
+import { ensureCnImport } from "../domain/imports.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/application/group-file.ts
+function printGroupFilePreview(logger, args) {
+	const { out } = logger;
+	const { filePath, reportTotal, cnInTvNoReplacement, cnInTvCalls, unwrapReplacementByCall, sourceText, sf, unwrapEdits, plannedGroupEdits } = args;
+	let header = `\n── ${filePath} (${reportTotal} site(s)`;
+	if (cnInTvNoReplacement > 0) header += `; plus ${cnInTvNoReplacement} cn() inside tv left unchanged (0 args)`;
+	header += `) ──`;
+	out(header);
+	for (const call of cnInTvCalls) {
+		const replacement = unwrapReplacementByCall.get(call);
+		if (replacement === void 0) {
+			out(`  Line ${lineOf(sf, call)} [tv ⊃ cn]: cn(...) has no arguments — skipped`);
+			continue;
+		}
+		const start = call.getStart(sf);
+		const end = call.getEnd();
+		if (sourceText.slice(start, end) === replacement) continue;
+		out(`  Line ${lineOf(sf, call)} [tv ⊃ cn → string/array]:`);
+		out(`  ${replacement.split("\n").join("\n  ")}`);
+	}
+	if (unwrapEdits.length > 0 && plannedGroupEdits.length > 0) out("  ([cn] / [tv] / [JSX className] lines below reflect content after unwrap of cn inside tv.)");
+	for (const plan of plannedGroupEdits) {
+		out(`  Line ${lineOf(plan.lineSf, plan.reportNode)} [${plan.label}]:`);
+		out(`  ${plan.replacement.split("\n").join("\n  ")}`);
+		out(`  // Buckets: ${JSON.stringify(plan.bucketSummary)}`);
+	}
+}
+function applyGroupFileWrites(filePath, options, fs, logger, unwrapEdits, textAfterUnwrap, plannedGroupEdits, cnInTvNoReplacement) {
+	const groupEdits = plannedGroupEdits.map((plannedEdit) => ({
+		start: plannedEdit.start,
+		end: plannedEdit.end,
+		replacement: plannedEdit.replacement,
+		jsxCn: plannedEdit.jsxCn
+	}));
+	const touchedJsxCn = groupEdits.some((groupEdit) => groupEdit.jsxCn);
+	let newText = groupEdits.length > 0 ? applyEditsDescending(textAfterUnwrap, groupEdits) : textAfterUnwrap;
+	const changed = unwrapEdits.length + groupEdits.length;
+	if (changed > 0) {
+		if (touchedJsxCn) newText = ensureCnImport(newText, filePath, options.cnImport);
+		fs.writeFileSync(filePath, newText, "utf8");
+	}
+	return {
+		filePath,
+		totalFound: changed + cnInTvNoReplacement,
+		changed
+	};
+}
+function groupFile(filePath, options, fs, logger) {
+	const sourceText = fs.readFileSync(filePath, "utf8");
+	const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const cnInTvCalls = listAllCnCallsInsideTvInSourceFile(sf, buildKnownCnTvBindings(sf));
+	const unwrapPlans = cnInTvCalls.map((call) => {
+		const replacement = unwrapCnInsideTvCallReplacement(call, sourceText, sf);
+		if (replacement === void 0) return;
+		return {
+			start: call.getStart(sf),
+			end: call.getEnd(),
+			replacement,
+			call
+		};
+	}).filter((planOrUndefined) => planOrUndefined !== void 0);
+	const unwrapReplacementByCall = new Map(unwrapPlans.map((unwrapPlan) => [unwrapPlan.call, unwrapPlan.replacement]));
+	const unwrapEdits = unwrapPlans.filter((unwrapPlan) => sourceText.slice(unwrapPlan.start, unwrapPlan.end) !== unwrapPlan.replacement);
+	const textAfterUnwrap = unwrapEdits.length > 0 ? applyEditsDescending(sourceText, unwrapEdits) : sourceText;
+	const groupTargets = collectGroupTargets(ts.createSourceFile(filePath, textAfterUnwrap, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS), filePath);
+	const cnInTvNoReplacement = cnInTvCalls.length - unwrapPlans.length;
+	const sortedTargets = [...groupTargets].sort((leftTarget, rightTarget) => targetReplaceStart(rightTarget) - targetReplaceStart(leftTarget));
+	const plannedGroupEdits = [];
+	for (const groupTarget of sortedTargets) {
+		const plan = planGroupEditForTarget(groupTarget, textAfterUnwrap, options.withClassName);
+		if (plan === void 0) continue;
+		if (textAfterUnwrap.slice(plan.start, plan.end) === plan.replacement) continue;
+		plannedGroupEdits.push(plan);
+	}
+	const editSitesCount = unwrapEdits.length + plannedGroupEdits.length;
+	const reportTotal = editSitesCount + cnInTvNoReplacement;
+	if (cnInTvCalls.length === 0 && groupTargets.length === 0) return {
+		filePath,
+		totalFound: 0,
+		changed: 0
+	};
+	if (!options.write) {
+		if (editSitesCount === 0 && cnInTvNoReplacement === 0) return {
+			filePath,
+			totalFound: 0,
+			changed: 0
+		};
+		printGroupFilePreview(logger, {
+			filePath,
+			reportTotal,
+			cnInTvNoReplacement,
+			cnInTvCalls,
+			unwrapReplacementByCall,
+			sourceText,
+			sf,
+			unwrapEdits,
+			plannedGroupEdits
+		});
+		return {
+			filePath,
+			totalFound: reportTotal,
+			changed: 0
+		};
+	}
+	return applyGroupFileWrites(filePath, options, fs, logger, unwrapEdits, textAfterUnwrap, plannedGroupEdits, cnInTvNoReplacement);
+}
+//#endregion
+export { groupFile };

package/dist/lib/arrange/application/run-target.mjs

@@ -0,0 +1,65 @@
+import { messageFromCaughtUnknown } from "../../infra/caught-unknown-message.mjs";
+import { walkTsxFiles } from "../infra/walk.mjs";
+import { groupFile } from "./group-file.mjs";
+import { ArrangeError, ArrangeErrorCode } from "../domain/errors.mjs";
+import path from "node:path";
+//#region src/lib/arrange/application/run-target.ts
+function runOnTarget(target, options, fs, logger) {
+	const { out } = logger;
+	if (!fs.existsSync(target)) throw new ArrangeError(ArrangeErrorCode.TARGET_NOT_FOUND, `Not found: ${target}`);
+	const filePaths = fs.statSync(target).isDirectory() ? walkTsxFiles(target, fs) : [target];
+	const modifiedFiles = [];
+	let totalFound = 0;
+	let totalChanged = 0;
+	for (const filePath of filePaths) {
+		const result = groupFile(filePath, options, fs, logger);
+		totalFound += result.totalFound;
+		totalChanged += result.changed;
+		if (result.changed > 0) modifiedFiles.push(result.filePath);
+	}
+	out(`\nTotal: ${filePaths.length} file(s), ${totalFound} site(s) (cn/tv/JSX className) to review.`);
+	if (options.write) out(`Applied: ${totalChanged} site(s) updated.`);
+	else out(`(Run "apply" to write changes, or "pnpm cli:arrange-apply" / "pnpm exec codefast arrange apply")`);
+	if (options.write ? totalChanged > 0 : totalFound > 0) out("Note: class order may change across concern groups — smoke-test the UI if you rely on cascade order.");
+	return {
+		filePaths,
+		modifiedFiles,
+		totalFound,
+		totalChanged
+	};
+}
+async function runArrangeOnAfterWriteHook(logger, hook, modifiedFiles) {
+	if (!hook || modifiedFiles.length === 0) return;
+	try {
+		await hook({ files: modifiedFiles });
+	} catch (caughtHookError) {
+		logger.err(`[arrange] onAfterWrite hook failed: ${messageFromCaughtUnknown(caughtHookError)}`);
+	}
+}
+/**
+* CLI entry: run arrange preview/apply using config injected by the command layer.
+* @returns Process exit code (`0`, or `1` when the target path is missing).
+*/
+async function runArrangeSync(opts) {
+	opts.rootDir;
+	const { fs, logger } = opts;
+	const resolvedTarget = path.resolve(opts.targetPath);
+	let result;
+	try {
+		result = runOnTarget(resolvedTarget, {
+			write: opts.write,
+			withClassName: !!opts.withClassName,
+			cnImport: opts.cnImport
+		}, fs, logger);
+	} catch (caughtError) {
+		if (caughtError instanceof ArrangeError && caughtError.code === ArrangeErrorCode.TARGET_NOT_FOUND) {
+			logger.err(caughtError.message);
+			return 1;
+		}
+		throw caughtError;
+	}
+	if (opts.write && result.modifiedFiles.length > 0) await runArrangeOnAfterWriteHook(logger, opts.config?.onAfterWrite, result.modifiedFiles);
+	return 0;
+}
+//#endregion
+export { runArrangeSync, runOnTarget };

package/dist/lib/arrange/domain/ast/ast-helpers.mjs

@@ -0,0 +1,115 @@
+import { EMPTY_CN_TV_BINDINGS } from "../constants.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/domain/ast/ast-helpers.ts
+/** Known module specifiers that export `cn` / `tv`. */
+const KNOWN_CN_TV_MODULES = new Set([
+	"@codefast/tailwind-variants",
+	"clsx",
+	"class-variance-authority",
+	"tailwind-variants",
+	"#lib/utils",
+	"~/lib/utils",
+	"@/lib/utils"
+]);
+/**
+* True for typical shadcn-style re-exports: `./utils`, `@/lib/utils`, `…/utils/…`,
+* or a dedicated `cn.ts` / `cn.tsx` module.
+*/
+function moduleLooksLikeCnTvReexport(moduleSpecifier) {
+	const norm = moduleSpecifier.replace(/\\/g, "/");
+	if (/(?:^|[./])utils(?:\/|$)/.test(norm)) return true;
+	if (/\/utils\//.test(norm) || /\/utils$/.test(norm)) return true;
+	if (/(?:^|\/)cn\.tsx?$/.test(norm)) return true;
+	return false;
+}
+/**
+* Build a set of local binding names that are imported from a known cn/tv
+* module in `sf`.
+*/
+function buildKnownCnTvBindings(sf) {
+	const bindings = /* @__PURE__ */ new Set();
+	for (const stmt of sf.statements) {
+		if (!ts.isImportDeclaration(stmt) || !stmt.importClause) continue;
+		if (stmt.importClause.isTypeOnly) continue;
+		const spec = stmt.moduleSpecifier;
+		if (!ts.isStringLiteral(spec)) continue;
+		const moduleSpecifier = spec.text;
+		if (!KNOWN_CN_TV_MODULES.has(moduleSpecifier) && !moduleLooksLikeCnTvReexport(moduleSpecifier)) continue;
+		const clause = stmt.importClause;
+		if (clause.name) bindings.add(clause.name.text);
+		if (!clause.namedBindings) continue;
+		if (ts.isNamedImports(clause.namedBindings)) {
+			for (const namedImport of clause.namedBindings.elements) bindings.add(namedImport.name.text);
+			continue;
+		}
+		bindings.add(clause.namedBindings.name.text);
+	}
+	return bindings;
+}
+/**
+* Returns true when `expr` is an identifier whose name matches `name` AND
+* that name is listed in `knownBindings` from a recognized import.
+*/
+function isCnOrTvIdentifier(expr, name, knownBindings = EMPTY_CN_TV_BINDINGS) {
+	if (knownBindings.size === 0) return false;
+	if (ts.isIdentifier(expr) && expr.text === name) return knownBindings.has(expr.text);
+	if (ts.isPropertyAccessExpression(expr) && expr.name.text === name) return ts.isIdentifier(expr.expression) && knownBindings.has(expr.expression.text);
+	return false;
+}
+function propertyAssignmentNameText(prop) {
+	if (ts.isIdentifier(prop.name)) return prop.name.text;
+	if (ts.isStringLiteral(prop.name)) return prop.name.text;
+}
+function lineOf(sf, tsNode) {
+	return sf.getLineAndCharacterOfPosition(tsNode.getStart(sf)).line + 1;
+}
+/**
+* Returns only the leading whitespace (tabs / spaces) of the line containing
+* `pos`.
+*/
+function indentOfLineContaining(source, pos) {
+	const searchPos = Math.max(0, Math.min(pos, source.length));
+	const prevLineBreak = Math.max(source.lastIndexOf("\n", searchPos - 1), source.lastIndexOf("\r", searchPos - 1));
+	const lineStart = prevLineBreak === -1 ? 0 : prevLineBreak + 1;
+	let lineEnd = source.length;
+	for (let i = lineStart; i < source.length; i++) {
+		const ch = source[i];
+		if (ch === "\n" || ch === "\r") {
+			lineEnd = i;
+			break;
+		}
+	}
+	const line = source.slice(lineStart, lineEnd);
+	return /^[\t ]*/.exec(line)?.[0] ?? "";
+}
+function applyEditsDescending(sourceText, edits) {
+	const sorted = [...edits].sort((editA, editB) => editB.start - editA.start);
+	let out = sourceText;
+	for (const edit of sorted) out = out.slice(0, edit.start) + edit.replacement + out.slice(edit.end);
+	return out;
+}
+/**
+* Replace `cn(...)` nested in `tv({...})` with a plain string (one arg) or a string
+* array (multiple args). Returns undefined when there are zero arguments.
+*/
+function unwrapCnInsideTvCallReplacement(call, sourceText, sf) {
+	const args = call.arguments;
+	if (args.length === 0) return;
+	const baseIndent = indentOfLineContaining(sourceText, call.getStart(sf));
+	const innerIndent = `${baseIndent}  `;
+	if (args.length === 1) {
+		const firstArg = args[0];
+		return sourceText.slice(firstArg.getStart(sf), firstArg.getEnd());
+	}
+	const lines = ["["];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		const piece = sourceText.slice(arg.getStart(sf), arg.getEnd());
+		const comma = i < args.length - 1 || args.length > 1 ? "," : "";
+		lines.push(`${innerIndent}${piece}${comma}`);
+	}
+	lines.push(`${baseIndent}]`);
+	return lines.join("\n");
+}
+//#endregion
+export { KNOWN_CN_TV_MODULES, applyEditsDescending, buildKnownCnTvBindings, indentOfLineContaining, isCnOrTvIdentifier, lineOf, moduleLooksLikeCnTvReexport, propertyAssignmentNameText, unwrapCnInsideTvCallReplacement };

package/dist/lib/arrange/domain/ast/collectors-cn.mjs

@@ -0,0 +1,61 @@
+import "../constants.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/domain/ast/collectors-cn.ts
+function forEachStringLiteralInClassExpression(expr, sink, depth = 0, options) {
+	if (depth > 12) return;
+	if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+		sink(expr);
+		return;
+	}
+	if (ts.isParenthesizedExpression(expr)) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isAsExpression(expr) || ts.isSatisfiesExpression(expr)) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isNonNullExpression(expr)) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isConditionalExpression(expr)) {
+		if (options?.descendIntoConditional === false) return;
+		forEachStringLiteralInClassExpression(expr.whenTrue, sink, depth + 1, options);
+		forEachStringLiteralInClassExpression(expr.whenFalse, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+		forEachStringLiteralInClassExpression(expr.left, sink, depth + 1, options);
+		forEachStringLiteralInClassExpression(expr.right, sink, depth + 1, options);
+		return;
+	}
+	if (ts.isArrayLiteralExpression(expr)) for (const arrayElement of expr.elements) {
+		if (ts.isSpreadElement(arrayElement)) continue;
+		forEachStringLiteralInClassExpression(arrayElement, sink, depth + 1, options);
+	}
+}
+function isUnsafeLiteralForCnStyleApplySplit(classLiteral) {
+	return ts.isArrayLiteralExpression(classLiteral.parent);
+}
+const CN_APPLY_LITERAL_WALK_OPTS = { descendIntoConditional: false };
+function collectUnconditionalTailwindLiteralsFromCnArguments(args) {
+	const staticLits = [];
+	for (const arg of args) if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+		if (!isUnsafeLiteralForCnStyleApplySplit(arg)) staticLits.push(arg);
+	} else forEachStringLiteralInClassExpression(arg, (lit) => {
+		if (!isUnsafeLiteralForCnStyleApplySplit(lit)) staticLits.push(lit);
+	}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+	return staticLits;
+}
+function mergeCnUnconditionalLiteralPoolForTest(argsSnippet, options) {
+	const callee = options?.callee ?? "cn";
+	const sourceText = `${callee}(${argsSnippet});`;
+	const stmt = ts.createSourceFile("mergeCnUnconditionalLiteralPoolForTest.ts", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
+	if (!ts.isExpressionStatement(stmt)) throw new Error("expected expression statement");
+	const call = stmt.expression;
+	if (!ts.isCallExpression(call) || !ts.isIdentifier(call.expression) || call.expression.text !== callee) throw new Error(`expected ${callee}(...) call`);
+	return collectUnconditionalTailwindLiteralsFromCnArguments(call.arguments).map((literal) => literal.text).join(" ");
+}
+//#endregion
+export { CN_APPLY_LITERAL_WALK_OPTS, collectUnconditionalTailwindLiteralsFromCnArguments, forEachStringLiteralInClassExpression, isUnsafeLiteralForCnStyleApplySplit, mergeCnUnconditionalLiteralPoolForTest };

package/dist/lib/arrange/domain/ast/collectors-jsx.mjs

@@ -0,0 +1,20 @@
+import ts from "typescript";
+//#region src/lib/arrange/domain/ast/collectors-jsx.ts
+function jsxClassNameStaticLiteral(jsxClassNameAttribute) {
+	if (!ts.isIdentifier(jsxClassNameAttribute.name) || jsxClassNameAttribute.name.text !== "className") return;
+	const init = jsxClassNameAttribute.initializer;
+	if (!init) return;
+	if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) return {
+		lit: init,
+		valueNode: init
+	};
+	if (ts.isJsxExpression(init) && init.expression) {
+		const jsxExpressionBody = init.expression;
+		if (ts.isStringLiteral(jsxExpressionBody) || ts.isNoSubstitutionTemplateLiteral(jsxExpressionBody)) return {
+			lit: jsxExpressionBody,
+			valueNode: init
+		};
+	}
+}
+//#endregion
+export { jsxClassNameStaticLiteral };

package/dist/lib/arrange/domain/ast/collectors-tv.mjs

@@ -0,0 +1,170 @@
+import "../constants.mjs";
+import { tokenizeClassString } from "../tokenizer.mjs";
+import { CN_APPLY_LITERAL_WALK_OPTS, collectUnconditionalTailwindLiteralsFromCnArguments, forEachStringLiteralInClassExpression, isUnsafeLiteralForCnStyleApplySplit } from "./collectors-cn.mjs";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText } from "./ast-helpers.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/domain/ast/collectors-tv.ts
+function traverseTvObject(sf, obj, visitor, depth = 0, knownBindings) {
+	if (depth > 12) return;
+	for (const prop of obj.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) visitor(init, sf, void 0);
+		else if (ts.isArrayLiteralExpression(init)) for (const arrayElement of init.elements) {
+			if (ts.isSpreadElement(arrayElement)) continue;
+			if (ts.isStringLiteral(arrayElement) || ts.isNoSubstitutionTemplateLiteral(arrayElement)) visitor(arrayElement, sf, void 0);
+			else if (ts.isCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) for (const arg of arrayElement.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+				visitor(lit, sf, arrayElement);
+			});
+			else if (ts.isObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+				if (!ts.isPropertyAssignment(objectProperty)) continue;
+				const propName = propertyAssignmentNameText(objectProperty);
+				if (propName !== "className" && propName !== "class") continue;
+				const innerInit = objectProperty.initializer;
+				if (ts.isStringLiteral(innerInit) || ts.isNoSubstitutionTemplateLiteral(innerInit)) visitor(innerInit, sf, void 0);
+				else if (ts.isArrayLiteralExpression(innerInit)) for (const nestedArrayElement of innerInit.elements) {
+					if (ts.isSpreadElement(nestedArrayElement)) continue;
+					if (ts.isStringLiteral(nestedArrayElement) || ts.isNoSubstitutionTemplateLiteral(nestedArrayElement)) visitor(nestedArrayElement, sf, void 0);
+				}
+				else if (ts.isCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) for (const arg of innerInit.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+					visitor(lit, sf, innerInit);
+				});
+			}
+		}
+		else if (ts.isObjectLiteralExpression(init)) traverseTvObject(sf, init, visitor, depth + 1, knownBindings);
+		else if (ts.isCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) for (const arg of init.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+			visitor(lit, sf, init);
+		});
+	}
+}
+function collectCnCallsInsideTv(sf, obj, knownBindings, depth = 0) {
+	if (depth > 12) return [];
+	const calls = [];
+	for (const prop of obj.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (ts.isArrayLiteralExpression(init)) for (const arrayElement of init.elements) {
+			if (ts.isSpreadElement(arrayElement)) continue;
+			if (ts.isCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) calls.push(arrayElement);
+			else if (ts.isObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+				if (!ts.isPropertyAssignment(objectProperty)) continue;
+				const propName = propertyAssignmentNameText(objectProperty);
+				if (propName !== "className" && propName !== "class") continue;
+				const innerInit = objectProperty.initializer;
+				if (ts.isCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) calls.push(innerInit);
+			}
+		}
+		else if (ts.isObjectLiteralExpression(init)) calls.push(...collectCnCallsInsideTv(sf, init, knownBindings, depth + 1));
+		else if (ts.isCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) calls.push(init);
+	}
+	return calls;
+}
+function listAllCnCallsInsideTvInSourceFile(sf, knownBindings) {
+	const calls = [];
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (ts.isCallExpression(tsNode) && isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+			const arg0 = tsNode.arguments[0];
+			if (arg0 && ts.isObjectLiteralExpression(arg0)) calls.push(...collectCnCallsInsideTv(sf, arg0, knownBindings, 0));
+		}
+		ts.forEachChild(tsNode, visitTypeScriptSubtree);
+	};
+	visitTypeScriptSubtree(sf);
+	return calls;
+}
+function makeStringNode(nodes, sf, isTvContext, cnCall) {
+	return {
+		nodes,
+		sf,
+		isTvContext,
+		cnCall,
+		get primaryClassLiteral() {
+			return this.nodes[0];
+		}
+	};
+}
+function slotClassString(stringNode) {
+	return stringNode.nodes.map((literal) => literal.text).join(" ");
+}
+function emitTvSlot(lits, sf, cnCall, results, seenNodePos) {
+	if (lits.length === 0) return;
+	const firstPos = lits[0].getStart(sf);
+	if (seenNodePos.has(firstPos)) return;
+	seenNodePos.add(firstPos);
+	if (lits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0) < 2) return;
+	results.push(makeStringNode(lits, sf, true, cnCall));
+}
+function collectTvSlots(sf, obj, knownBindings, results, seenNodePos, depth = 0) {
+	if (depth > 12) return;
+	for (const prop of obj.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) emitTvSlot([init], sf, void 0, results, seenNodePos);
+		else if (ts.isArrayLiteralExpression(init)) {
+			const arrayPos = init.getStart(sf);
+			if (seenNodePos.has(arrayPos)) continue;
+			seenNodePos.add(arrayPos);
+			const staticLits = [];
+			for (const arrayElement of init.elements) {
+				if (ts.isSpreadElement(arrayElement)) continue;
+				if (ts.isStringLiteral(arrayElement) || ts.isNoSubstitutionTemplateLiteral(arrayElement)) staticLits.push(arrayElement);
+				else if (ts.isCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) for (const arg of arrayElement.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+					if (!isUnsafeLiteralForCnStyleApplySplit(lit)) staticLits.push(lit);
+				}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+				else if (ts.isObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+					if (!ts.isPropertyAssignment(objectProperty)) continue;
+					const propName = propertyAssignmentNameText(objectProperty);
+					if (propName !== "className" && propName !== "class") continue;
+					const innerInit = objectProperty.initializer;
+					if (ts.isStringLiteral(innerInit) || ts.isNoSubstitutionTemplateLiteral(innerInit)) emitTvSlot([innerInit], sf, void 0, results, seenNodePos);
+					else if (ts.isArrayLiteralExpression(innerInit)) {
+						const innerLits = [];
+						for (const nestedArrayElement of innerInit.elements) if (!ts.isSpreadElement(nestedArrayElement) && (ts.isStringLiteral(nestedArrayElement) || ts.isNoSubstitutionTemplateLiteral(nestedArrayElement))) innerLits.push(nestedArrayElement);
+						emitTvSlot(innerLits, sf, void 0, results, seenNodePos);
+					} else if (ts.isCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
+						const cnLits = [];
+						for (const arg of innerInit.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+							if (!isUnsafeLiteralForCnStyleApplySplit(lit)) cnLits.push(lit);
+						}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+						emitTvSlot(cnLits, sf, innerInit, results, seenNodePos);
+					}
+				}
+			}
+			if (staticLits.length > 0) emitTvSlot(staticLits, sf, void 0, results, seenNodePos);
+		} else if (ts.isObjectLiteralExpression(init)) collectTvSlots(sf, init, knownBindings, results, seenNodePos, depth + 1);
+		else if (ts.isCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
+			const cnLits = [];
+			for (const arg of init.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+				if (!isUnsafeLiteralForCnStyleApplySplit(lit)) cnLits.push(lit);
+			}, 0, CN_APPLY_LITERAL_WALK_OPTS);
+			emitTvSlot(cnLits, sf, init, results, seenNodePos);
+		}
+	}
+}
+function collectGroupableStringNodes(sf) {
+	const results = [];
+	const seenNodePos = /* @__PURE__ */ new Set();
+	const knownBindings = buildKnownCnTvBindings(sf);
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (ts.isCallExpression(tsNode)) {
+			if (isCnOrTvIdentifier(tsNode.expression, "cn", knownBindings)) {
+				const callPos = tsNode.getStart(sf);
+				if (seenNodePos.has(callPos)) {
+					ts.forEachChild(tsNode, visitTypeScriptSubtree);
+					return;
+				}
+				seenNodePos.add(callPos);
+				const staticLits = collectUnconditionalTailwindLiteralsFromCnArguments(tsNode.arguments);
+				const totalTokens = staticLits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0);
+				if (staticLits.length > 0 && totalTokens >= 2) results.push(makeStringNode(staticLits, sf, false, tsNode));
+			} else if (isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+				const arg0 = tsNode.arguments[0];
+				if (arg0 && ts.isObjectLiteralExpression(arg0)) collectTvSlots(sf, arg0, knownBindings, results, seenNodePos);
+			}
+		}
+		ts.forEachChild(tsNode, visitTypeScriptSubtree);
+	};
+	visitTypeScriptSubtree(sf);
+	return results;
+}
+//#endregion
+export { collectCnCallsInsideTv, collectGroupableStringNodes, collectTvSlots, emitTvSlot, listAllCnCallsInsideTvInSourceFile, makeStringNode, slotClassString, traverseTvObject };

package/dist/lib/arrange/domain/ast/targets.mjs

@@ -0,0 +1,106 @@
+import "../constants.mjs";
+import { tokenizeClassString } from "../tokenizer.mjs";
+import { isUnsafeLiteralForCnStyleApplySplit } from "./collectors-cn.mjs";
+import { jsxClassNameStaticLiteral } from "./collectors-jsx.mjs";
+import { indentOfLineContaining } from "./ast-helpers.mjs";
+import { collectGroupableStringNodes, slotClassString } from "./collectors-tv.mjs";
+import { areCnTailwindPartitionsEquivalent, suggestCnGroups, summarizeGroupBucketLabels } from "../grouping.mjs";
+import { escapeTsStringLiteralContent, formatArray, formatJsxCnAttributeValue } from "../../presentation/formatters.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/domain/ast/targets.ts
+function targetReplaceStart(target) {
+	if (target.kind === "cnArg") return target.item.cnCall ? target.item.cnCall.getStart(target.item.sf) : target.item.primaryClassLiteral.getStart(target.item.sf);
+	return target.valueNode.getStart(target.sf);
+}
+function collectLongJsxClassNameTargets(sf) {
+	const results = [];
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (ts.isJsxAttribute(tsNode)) {
+			const parsed = jsxClassNameStaticLiteral(tsNode);
+			if (parsed && tokenizeClassString(parsed.lit.text).length >= 2) results.push({
+				kind: "jsxClassName",
+				sf,
+				lit: parsed.lit,
+				valueNode: parsed.valueNode
+			});
+		}
+		ts.forEachChild(tsNode, visitTypeScriptSubtree);
+	};
+	visitTypeScriptSubtree(sf);
+	return results;
+}
+function collectGroupTargets(sf, filePath) {
+	const cnPart = collectGroupableStringNodes(sf).map((stringNode) => ({
+		kind: "cnArg",
+		item: stringNode
+	}));
+	if (!filePath.endsWith(".tsx")) return cnPart;
+	return [...cnPart, ...collectLongJsxClassNameTargets(sf)];
+}
+function formatCnCallReplacement(stringNode, sourceText, withClassName) {
+	const call = stringNode.cnCall;
+	const sf = stringNode.sf;
+	const baseIndent = indentOfLineContaining(sourceText, call.getStart(sf));
+	const argIndent = `${baseIndent}  `;
+	const dynamicArgTexts = [];
+	for (const arg of call.arguments) if (!((ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) && !isUnsafeLiteralForCnStyleApplySplit(arg))) dynamicArgTexts.push(sourceText.slice(arg.getStart(sf), arg.getEnd()));
+	const pool = slotClassString(stringNode);
+	const groups = pool.trim() ? suggestCnGroups(pool) : [];
+	const allArgs = [];
+	if (groups.length > 1) for (const group of groups) allArgs.push(`${argIndent}"${escapeTsStringLiteralContent(group)}"`);
+	else if (groups.length === 1) allArgs.push(`${argIndent}"${escapeTsStringLiteralContent(groups[0])}"`);
+	for (const dynamicArgumentSource of dynamicArgTexts) allArgs.push(`${argIndent}${dynamicArgumentSource}`);
+	if (withClassName) allArgs.push(`${argIndent}className`);
+	const commaAfterLastArg = allArgs.length > 1;
+	return `cn(\n${allArgs.map((argLine, lineIndex) => lineIndex < allArgs.length - 1 || commaAfterLastArg ? `${argLine},` : `${argLine}`).join("\n")}\n${baseIndent})`;
+}
+function planGroupEditForTarget(target, textAfterUnwrap, withClassName) {
+	if (target.kind === "jsxClassName") {
+		const groups = suggestCnGroups(target.lit.text);
+		if (groups.length <= 1) return;
+		const start = target.valueNode.getStart(target.sf);
+		return {
+			start,
+			end: target.valueNode.getEnd(),
+			replacement: formatJsxCnAttributeValue(groups, textAfterUnwrap, start),
+			bucketSummary: summarizeGroupBucketLabels(groups),
+			jsxCn: true,
+			lineSf: target.sf,
+			reportNode: target.lit,
+			label: "JSX className"
+		};
+	}
+	const groups = suggestCnGroups(slotClassString(target.item));
+	if (groups.length <= 1) return;
+	if (areCnTailwindPartitionsEquivalent(target.item.nodes.map((classLiteral) => classLiteral.text), groups)) return;
+	if (!target.item.cnCall) {
+		const anchorClassLiteral = target.item.primaryClassLiteral;
+		const parentArray = target.item.nodes.length > 1 && ts.isArrayLiteralExpression(anchorClassLiteral.parent) ? anchorClassLiteral.parent : null;
+		const start = parentArray ? parentArray.getStart(target.item.sf) : anchorClassLiteral.getStart(target.item.sf);
+		const end = parentArray ? parentArray.getEnd() : anchorClassLiteral.getEnd();
+		const baseIndent = indentOfLineContaining(textAfterUnwrap, start);
+		return {
+			start,
+			end,
+			replacement: formatArray(groups).split("\n").map((line, lineIndex) => lineIndex === 0 ? line : `${baseIndent}${line}`).join("\n"),
+			bucketSummary: summarizeGroupBucketLabels(groups),
+			jsxCn: false,
+			lineSf: target.item.sf,
+			reportNode: anchorClassLiteral,
+			label: target.item.isTvContext ? "tv" : "cn"
+		};
+	}
+	const call = target.item.cnCall;
+	return {
+		start: call.getStart(target.item.sf),
+		end: call.getEnd(),
+		replacement: formatCnCallReplacement(target.item, textAfterUnwrap, withClassName),
+		bucketSummary: summarizeGroupBucketLabels(groups),
+		jsxCn: false,
+		lineSf: target.item.sf,
+		reportNode: target.item.primaryClassLiteral,
+		label: target.item.isTvContext ? "tv" : "cn"
+	};
+}
+//#endregion
+export { collectGroupTargets, collectLongJsxClassNameTargets, formatCnCallReplacement, planGroupEditForTarget, targetReplaceStart };