@codefast/cli 0.3.13-canary.3 → 0.3.13

package/dist/lib/arrange/domain/arrange-analyze.service.mjs

@@ -0,0 +1,95 @@
+import "./constants.domain.mjs";
+import { forEachDomainChild, isDomainCallExpression, isDomainJsxAttribute, isDomainObjectLiteralExpression } from "./ast/ast-node.model.mjs";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, lineOf } from "./ast/ast-helpers.helper.mjs";
+import { forEachStringLiteralInClassExpression } from "./ast/collectors-cn.collector.mjs";
+import { tokenizeClassString } from "./tokenizer.util.mjs";
+import { collectCnCallsInsideTv, traverseTvObject } from "./ast/collectors-tv.collector.mjs";
+import { jsxClassNameStaticLiteral } from "./ast/collectors-jsx.collector.mjs";
+//#region src/lib/arrange/domain/arrange-analyze.service.ts
+/**
+* Rich domain: Tailwind/cn/tv analysis rules (counts, long literals, nested cn in tv).
+* Pure orchestration of domain collectors and invariants — no I/O.
+*/ const PREVIEW_MAX_LENGTH = 72;
+function previewText(text) {
+	return text.length > PREVIEW_MAX_LENGTH ? `${text.slice(0, PREVIEW_MAX_LENGTH)}…` : text;
+}
+function createEmptyAnalyzeReport() {
+	return {
+		files: 0,
+		cnCallExpressions: 0,
+		tvCallExpressions: 0,
+		cnInsideTvCalls: [],
+		longCnStringLiterals: [],
+		longTvStringLiterals: [],
+		longJsxClassNameLiterals: []
+	};
+}
+function analyzeCnCall(domainSf, call, report) {
+	for (const arg of call.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+		const text = lit.text;
+		const tokenCount = tokenizeClassString(text).length;
+		if (tokenCount >= 18) report.longCnStringLiterals.push({
+			file: domainSf.fileName,
+			line: lineOf(domainSf, lit),
+			tokenCount,
+			preview: previewText(text)
+		});
+	});
+}
+function visitCallExpressionForArrangeAnalyze(callExpression, domainSf, sourceText, knownBindings, report) {
+	if (isCnOrTvIdentifier(callExpression.expression, "cn", knownBindings)) {
+		report.cnCallExpressions++;
+		analyzeCnCall(domainSf, callExpression, report);
+		return;
+	}
+	if (!isCnOrTvIdentifier(callExpression.expression, "tv", knownBindings)) return;
+	report.tvCallExpressions++;
+	const arg0 = callExpression.arguments[0];
+	if (!arg0 || !isDomainObjectLiteralExpression(arg0)) return;
+	for (const nestedCn of collectCnCallsInsideTv(domainSf, arg0, knownBindings, 0)) {
+		const src = sourceText.slice(nestedCn.pos, nestedCn.end);
+		report.cnInsideTvCalls.push({
+			file: domainSf.fileName,
+			line: lineOf(domainSf, nestedCn),
+			argCount: nestedCn.arguments.length,
+			preview: previewText(src)
+		});
+	}
+	traverseTvObject(domainSf, arg0, (classLiteral) => {
+		const text = classLiteral.text;
+		const tokenCount = tokenizeClassString(text).length;
+		if (tokenCount >= 18) report.longTvStringLiterals.push({
+			file: domainSf.fileName,
+			line: lineOf(domainSf, classLiteral),
+			tokenCount,
+			preview: previewText(text)
+		});
+	}, 0, knownBindings);
+}
+function visitJsxAttributeForArrangeAnalyze(jsxClassAttribute, domainSf, filePath, report) {
+	if (!filePath.endsWith(".tsx")) return;
+	const parsed = jsxClassNameStaticLiteral(jsxClassAttribute);
+	if (!parsed) return;
+	const text = parsed.lit.text;
+	const tokenCount = tokenizeClassString(text).length;
+	if (tokenCount >= 18) report.longJsxClassNameLiterals.push({
+		file: domainSf.fileName,
+		line: lineOf(domainSf, parsed.lit),
+		tokenCount,
+		preview: previewText(text)
+	});
+}
+/**
+* Accumulates findings for one parsed source file into `report` (mutates report).
+*/ function accumulateAnalyzeReportForSourceFile(report, domainSf, sourceText, filePath) {
+	report.files++;
+	const knownBindings = buildKnownCnTvBindings(domainSf);
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (isDomainCallExpression(tsNode)) visitCallExpressionForArrangeAnalyze(tsNode, domainSf, sourceText, knownBindings, report);
+		if (isDomainJsxAttribute(tsNode)) visitJsxAttributeForArrangeAnalyze(tsNode, domainSf, filePath, report);
+		forEachDomainChild(tsNode, visitTypeScriptSubtree);
+	};
+	for (const stmt of domainSf.statements) visitTypeScriptSubtree(stmt);
+}
+//#endregion
+export { accumulateAnalyzeReportForSourceFile, createEmptyAnalyzeReport };

package/dist/lib/arrange/domain/arrange-grouping.service.mjs

@@ -0,0 +1,100 @@
+import { applyEditsDescending } from "../../shared/source-code/domain/text-edit.model.mjs";
+import { buildKnownCnTvBindings, unwrapCnInsideTvCallReplacement } from "./ast/ast-helpers.helper.mjs";
+import { listAllCnCallsInsideTvInSourceFile } from "./ast/collectors-tv.collector.mjs";
+import { collectGroupTargets, planGroupEditForTarget, targetReplaceStart } from "./ast/targets.model.mjs";
+//#region src/lib/arrange/domain/arrange-grouping.service.ts
+/**
+* Rich domain: plan Tailwind class grouping / cn-in-tv unwrap for a single file.
+* Pure: only DomainSourceFile, source strings, and options — no I/O.
+*/ function toUnwrapPlans(cnInTvCalls, sourceText) {
+	return cnInTvCalls.map((call) => {
+		const replacement = unwrapCnInsideTvCallReplacement(call, sourceText);
+		if (replacement === void 0) return;
+		return {
+			start: call.pos,
+			end: call.end,
+			replacement,
+			call
+		};
+	}).filter((plan) => plan !== void 0);
+}
+function buildGroupFileUnwrapState(domainSfInitial, sourceText) {
+	const cnInTvCalls = listAllCnCallsInsideTvInSourceFile(domainSfInitial, buildKnownCnTvBindings(domainSfInitial));
+	const unwrapPlans = toUnwrapPlans(cnInTvCalls, sourceText);
+	const unwrapReplacementByCall = new Map(unwrapPlans.map((unwrapPlan) => [unwrapPlan.call, unwrapPlan.replacement]));
+	const unwrapEdits = unwrapPlans.filter((unwrapPlan) => sourceText.slice(unwrapPlan.start, unwrapPlan.end) !== unwrapPlan.replacement);
+	return {
+		cnInTvCalls,
+		unwrapReplacementByCall,
+		unwrapEdits,
+		textAfterUnwrap: unwrapEdits.length > 0 ? applyEditsDescending(sourceText, [...unwrapEdits]) : sourceText,
+		cnInTvNoReplacement: cnInTvCalls.length - unwrapPlans.length
+	};
+}
+/**
+* `domainSfGrouped` must be a parse of `unwrap.textAfterUnwrap` (same `text` as source).
+* Returns `null` when there is no cn-in-tv and no grouping targets.
+*/ function tryBuildGroupFileWorkPlan(input) {
+	const { filePath, sourceText, domainSfInitial, domainSfGrouped, withClassName, unwrap } = input;
+	if (domainSfGrouped.text !== unwrap.textAfterUnwrap) throw new Error("Domain invariant: domainSfGrouped.text must match unwrap phase textAfterUnwrap");
+	const groupTargets = collectGroupTargets(domainSfGrouped, filePath);
+	if (unwrap.cnInTvCalls.length === 0 && groupTargets.length === 0) return null;
+	const sortedTargets = [...groupTargets].sort((leftTarget, rightTarget) => targetReplaceStart(rightTarget) - targetReplaceStart(leftTarget));
+	const plannedGroupEdits = [];
+	for (const groupTarget of sortedTargets) {
+		const plan = planGroupEditForTarget(groupTarget, unwrap.textAfterUnwrap, withClassName);
+		if (plan === void 0) continue;
+		if (unwrap.textAfterUnwrap.slice(plan.start, plan.end) === plan.replacement) continue;
+		plannedGroupEdits.push(plan);
+	}
+	const editSitesCount = unwrap.unwrapEdits.length + plannedGroupEdits.length;
+	const reportTotal = editSitesCount + unwrap.cnInTvNoReplacement;
+	return {
+		filePath,
+		sourceText,
+		textAfterUnwrap: unwrap.textAfterUnwrap,
+		domainSfForLineNumbers: domainSfInitial,
+		domainSfGrouped,
+		cnInTvCalls: unwrap.cnInTvCalls,
+		unwrapReplacementByCall: unwrap.unwrapReplacementByCall,
+		unwrapEdits: unwrap.unwrapEdits,
+		plannedGroupEdits,
+		cnInTvNoReplacement: unwrap.cnInTvNoReplacement,
+		reportTotal,
+		editSitesCount
+	};
+}
+function groupFileDryRunNoEdits(filePath) {
+	return {
+		filePath,
+		totalFound: 0,
+		changed: 0
+	};
+}
+function groupFilePreviewTotals(work) {
+	return {
+		filePath: work.filePath,
+		totalFound: work.reportTotal,
+		changed: 0
+	};
+}
+function mergeGroupFileBodyText(work) {
+	const groupEdits = work.plannedGroupEdits.map((plannedEdit) => ({
+		start: plannedEdit.start,
+		end: plannedEdit.end,
+		replacement: plannedEdit.replacement,
+		jsxCn: plannedEdit.jsxCn
+	}));
+	return groupEdits.length > 0 ? applyEditsDescending(work.textAfterUnwrap, groupEdits) : work.textAfterUnwrap;
+}
+function groupFileEditsTouchJsxCn(work) {
+	return work.plannedGroupEdits.some((plannedEdit) => plannedEdit.jsxCn);
+}
+function countPersistedGroupFileEdits(work) {
+	return work.unwrapEdits.length + work.plannedGroupEdits.length;
+}
+function groupFileWorkHasNothingToReport(work) {
+	return work.editSitesCount === 0 && work.cnInTvNoReplacement === 0;
+}
+//#endregion
+export { buildGroupFileUnwrapState, countPersistedGroupFileEdits, groupFileDryRunNoEdits, groupFileEditsTouchJsxCn, groupFilePreviewTotals, groupFileWorkHasNothingToReport, mergeGroupFileBodyText, tryBuildGroupFileWorkPlan };

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

@@ -0,0 +1,89 @@
+import { EMPTY_CN_TV_BINDINGS } from "../constants.domain.mjs";
+import { applyEditsDescending, indentOfLineContaining } from "../../../shared/source-code/domain/text-edit.model.mjs";
+import { isDomainIdentifier, isDomainImportDeclaration, isDomainNamedImports, isDomainNamespaceImport, isDomainPropertyAccessExpression, isDomainStringLiteral, lineOfSourcePosition } from "./ast-node.model.mjs";
+//#region src/lib/arrange/domain/ast/ast-helpers.helper.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 `sourceFile`.
+*/ function buildKnownCnTvBindings(sourceFile) {
+	const bindings = /* @__PURE__ */ new Set();
+	for (const stmt of sourceFile.statements) {
+		if (!isDomainImportDeclaration(stmt) || !stmt.importClause) continue;
+		if (stmt.importClause.isTypeOnly) continue;
+		const spec = stmt.moduleSpecifier;
+		if (!isDomainStringLiteral(spec)) continue;
+		const moduleSpecifierText = spec.text;
+		if (!KNOWN_CN_TV_MODULES.has(moduleSpecifierText) && !moduleLooksLikeCnTvReexport(moduleSpecifierText)) continue;
+		const clause = stmt.importClause;
+		if (clause.name) bindings.add(clause.name.text);
+		const { namedBindings } = clause;
+		if (!namedBindings) continue;
+		if (isDomainNamedImports(namedBindings)) {
+			for (const namedImport of namedBindings.elements) bindings.add(namedImport.name.text);
+			continue;
+		}
+		if (isDomainNamespaceImport(namedBindings)) bindings.add(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 (isDomainIdentifier(expr) && expr.text === name) return knownBindings.has(expr.text);
+	if (isDomainPropertyAccessExpression(expr) && expr.name.text === name) return isDomainIdentifier(expr.expression) && knownBindings.has(expr.expression.text);
+	return false;
+}
+function propertyAssignmentNameText(prop) {
+	if (isDomainIdentifier(prop.name)) return prop.name.text;
+	if (isDomainStringLiteral(prop.name)) return prop.name.text;
+}
+function lineOf(sourceFile, node) {
+	return lineOfSourcePosition(sourceFile.text, node.pos);
+}
+/**
+* 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) {
+	const args = call.arguments;
+	if (args.length === 0) return;
+	const baseIndent = indentOfLineContaining(sourceText, call.pos);
+	const innerIndent = `${baseIndent}  `;
+	if (args.length === 1) {
+		const firstArg = args[0];
+		if (firstArg === void 0) return;
+		return sourceText.slice(firstArg.pos, firstArg.end);
+	}
+	const lines = ["["];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === void 0) throw new Error("invariant: unwrapCnInsideTvCall argument missing");
+		const piece = sourceText.slice(arg.pos, arg.end);
+		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/ast-node.model.mjs

@@ -0,0 +1,181 @@
+//#region src/lib/arrange/domain/ast/ast-node.model.ts
+/**
+* Pure-domain AST shapes for arrange analysis. No TypeScript compiler types.
+* Positions mirror `getStart(sourceFile)` / `getEnd()` semantics from translation.
+*/ var DomainSyntaxKind = /* @__PURE__ */ function(DomainSyntaxKind) {
+	DomainSyntaxKind[DomainSyntaxKind["Unknown"] = 1] = "Unknown";
+	DomainSyntaxKind[DomainSyntaxKind["Identifier"] = 2] = "Identifier";
+	DomainSyntaxKind[DomainSyntaxKind["StringLiteral"] = 3] = "StringLiteral";
+	DomainSyntaxKind[DomainSyntaxKind["NoSubstitutionTemplateLiteral"] = 4] = "NoSubstitutionTemplateLiteral";
+	DomainSyntaxKind[DomainSyntaxKind["ImportDeclaration"] = 5] = "ImportDeclaration";
+	DomainSyntaxKind[DomainSyntaxKind["ImportClause"] = 6] = "ImportClause";
+	DomainSyntaxKind[DomainSyntaxKind["NamedImports"] = 7] = "NamedImports";
+	DomainSyntaxKind[DomainSyntaxKind["NamespaceImport"] = 8] = "NamespaceImport";
+	DomainSyntaxKind[DomainSyntaxKind["ImportSpecifier"] = 9] = "ImportSpecifier";
+	DomainSyntaxKind[DomainSyntaxKind["CallExpression"] = 10] = "CallExpression";
+	DomainSyntaxKind[DomainSyntaxKind["PropertyAccessExpression"] = 11] = "PropertyAccessExpression";
+	DomainSyntaxKind[DomainSyntaxKind["ObjectLiteralExpression"] = 12] = "ObjectLiteralExpression";
+	DomainSyntaxKind[DomainSyntaxKind["PropertyAssignment"] = 13] = "PropertyAssignment";
+	DomainSyntaxKind[DomainSyntaxKind["ArrayLiteralExpression"] = 14] = "ArrayLiteralExpression";
+	DomainSyntaxKind[DomainSyntaxKind["SpreadElement"] = 15] = "SpreadElement";
+	DomainSyntaxKind[DomainSyntaxKind["ParenthesizedExpression"] = 16] = "ParenthesizedExpression";
+	DomainSyntaxKind[DomainSyntaxKind["AsExpression"] = 17] = "AsExpression";
+	DomainSyntaxKind[DomainSyntaxKind["SatisfiesExpression"] = 18] = "SatisfiesExpression";
+	DomainSyntaxKind[DomainSyntaxKind["NonNullExpression"] = 19] = "NonNullExpression";
+	DomainSyntaxKind[DomainSyntaxKind["ConditionalExpression"] = 20] = "ConditionalExpression";
+	DomainSyntaxKind[DomainSyntaxKind["BinaryExpression"] = 21] = "BinaryExpression";
+	DomainSyntaxKind[DomainSyntaxKind["ExpressionStatement"] = 22] = "ExpressionStatement";
+	DomainSyntaxKind[DomainSyntaxKind["JsxAttribute"] = 23] = "JsxAttribute";
+	DomainSyntaxKind[DomainSyntaxKind["JsxExpression"] = 24] = "JsxExpression";
+	return DomainSyntaxKind;
+}({});
+var DomainBinaryOperator = /* @__PURE__ */ function(DomainBinaryOperator) {
+	DomainBinaryOperator[DomainBinaryOperator["Plus"] = 0] = "Plus";
+	DomainBinaryOperator[DomainBinaryOperator["Other"] = 1] = "Other";
+	return DomainBinaryOperator;
+}({});
+function isDomainIdentifier(node) {
+	return node.kind === 2;
+}
+function isDomainStringLiteral(node) {
+	return node.kind === 3;
+}
+function isDomainNoSubstitutionTemplateLiteral(node) {
+	return node.kind === 4;
+}
+function isDomainTailwindClassLiteral(node) {
+	return isDomainStringLiteral(node) || isDomainNoSubstitutionTemplateLiteral(node);
+}
+function isDomainImportDeclaration(node) {
+	return node.kind === 5;
+}
+function isDomainImportClause(node) {
+	return node !== void 0 && node.kind === 6;
+}
+function isDomainNamedImports(node) {
+	return node.kind === 7;
+}
+function isDomainNamespaceImport(node) {
+	return node.kind === 8;
+}
+function isDomainCallExpression(node) {
+	return node.kind === 10;
+}
+function isDomainObjectLiteralExpression(node) {
+	return node.kind === 12;
+}
+function isDomainPropertyAssignment(node) {
+	return node.kind === 13;
+}
+function isDomainArrayLiteralExpression(node) {
+	return node.kind === 14;
+}
+function isDomainSpreadElement(node) {
+	return node.kind === 15;
+}
+function isDomainPropertyAccessExpression(node) {
+	return node.kind === 11;
+}
+function isDomainJsxAttribute(node) {
+	return node.kind === 23;
+}
+function isDomainJsxExpression(node) {
+	return node.kind === 24;
+}
+function isDomainExpressionStatement(node) {
+	return node.kind === 22;
+}
+function forEachDomainChild(node, visit) {
+	switch (node.kind) {
+		case 1:
+			for (const child of node.children) visit(child);
+			return;
+		case 5:
+			if (node.importClause) visit(node.importClause);
+			visit(node.moduleSpecifier);
+			return;
+		case 6:
+			if (node.name) visit(node.name);
+			if (node.namedBindings) visit(node.namedBindings);
+			return;
+		case 7:
+			for (const element of node.elements) visit(element);
+			return;
+		case 8:
+			visit(node.name);
+			return;
+		case 9:
+			if (node.propertyName) visit(node.propertyName);
+			visit(node.name);
+			return;
+		case 10:
+			visit(node.expression);
+			for (const arg of node.arguments) visit(arg);
+			return;
+		case 11:
+			visit(node.expression);
+			visit(node.name);
+			return;
+		case 12:
+			for (const prop of node.properties) visit(prop);
+			return;
+		case 13:
+			visit(node.name);
+			visit(node.initializer);
+			return;
+		case 14:
+			for (const element of node.elements) visit(element);
+			return;
+		case 15:
+			visit(node.expression);
+			return;
+		case 16:
+		case 17:
+		case 18:
+		case 19:
+			visit(node.expression);
+			return;
+		case 20:
+			visit(node.condition);
+			visit(node.whenTrue);
+			visit(node.whenFalse);
+			return;
+		case 21:
+			visit(node.left);
+			visit(node.right);
+			return;
+		case 22:
+			visit(node.expression);
+			return;
+		case 23:
+			visit(node.name);
+			if (node.initializer) visit(node.initializer);
+			return;
+		case 24:
+			if (node.expression) visit(node.expression);
+			return;
+		default: return;
+	}
+}
+function forEachDomainDescendant(node, visit) {
+	visit(node);
+	forEachDomainChild(node, (child) => forEachDomainDescendant(child, visit));
+}
+function forEachDomainDescendantFromSourceFile(sourceFile, visit) {
+	for (const statement of sourceFile.statements) forEachDomainDescendant(statement, visit);
+}
+function findFirstDomainDescendantWhere(sourceFile, predicate) {
+	let found;
+	forEachDomainDescendantFromSourceFile(sourceFile, (n) => {
+		if (found === void 0 && predicate(n)) found = n;
+	});
+	return found;
+}
+function lineOfSourcePosition(sourceText, pos) {
+	const boundedPos = Math.max(0, Math.min(pos, sourceText.length));
+	let line = 1;
+	for (let i = 0; i < boundedPos; i++) if (sourceText.charCodeAt(i) === 10) line++;
+	return line;
+}
+//#endregion
+export { DomainBinaryOperator, DomainSyntaxKind, findFirstDomainDescendantWhere, forEachDomainChild, forEachDomainDescendant, forEachDomainDescendantFromSourceFile, isDomainArrayLiteralExpression, isDomainCallExpression, isDomainExpressionStatement, isDomainIdentifier, isDomainImportClause, isDomainImportDeclaration, isDomainJsxAttribute, isDomainJsxExpression, isDomainNamedImports, isDomainNamespaceImport, isDomainNoSubstitutionTemplateLiteral, isDomainObjectLiteralExpression, isDomainPropertyAccessExpression, isDomainPropertyAssignment, isDomainSpreadElement, isDomainStringLiteral, isDomainTailwindClassLiteral, lineOfSourcePosition };

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

@@ -0,0 +1,52 @@
+import "../constants.domain.mjs";
+import { DomainBinaryOperator, DomainSyntaxKind, isDomainArrayLiteralExpression, isDomainTailwindClassLiteral } from "./ast-node.model.mjs";
+//#region src/lib/arrange/domain/ast/collectors-cn.collector.ts
+function forEachStringLiteralInClassExpression(expr, sink, depth = 0, options) {
+	if (depth > 12) return;
+	if (isDomainTailwindClassLiteral(expr)) {
+		sink(expr);
+		return;
+	}
+	if (expr.kind === DomainSyntaxKind.ParenthesizedExpression) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (expr.kind === DomainSyntaxKind.AsExpression || expr.kind === DomainSyntaxKind.SatisfiesExpression) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (expr.kind === DomainSyntaxKind.NonNullExpression) {
+		forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+		return;
+	}
+	if (expr.kind === DomainSyntaxKind.ConditionalExpression) {
+		if (options?.descendIntoConditional === false) return;
+		forEachStringLiteralInClassExpression(expr.whenTrue, sink, depth + 1, options);
+		forEachStringLiteralInClassExpression(expr.whenFalse, sink, depth + 1, options);
+		return;
+	}
+	if (expr.kind === DomainSyntaxKind.BinaryExpression && expr.operator === DomainBinaryOperator.Plus) {
+		forEachStringLiteralInClassExpression(expr.left, sink, depth + 1, options);
+		forEachStringLiteralInClassExpression(expr.right, sink, depth + 1, options);
+		return;
+	}
+	if (isDomainArrayLiteralExpression(expr)) for (const arrayElement of expr.elements) {
+		if (arrayElement.kind === DomainSyntaxKind.SpreadElement) continue;
+		forEachStringLiteralInClassExpression(arrayElement, sink, depth + 1, options);
+	}
+}
+function isUnsafeLiteralForCnStyleApplySplit(classLiteral) {
+	return classLiteral.parent !== null && isDomainArrayLiteralExpression(classLiteral.parent);
+}
+const CN_APPLY_LITERAL_WALK_OPTS = { descendIntoConditional: false };
+function collectUnconditionalTailwindLiteralsFromCnArguments(args) {
+	const staticLits = [];
+	for (const arg of args) if (isDomainTailwindClassLiteral(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;
+}
+//#endregion
+export { CN_APPLY_LITERAL_WALK_OPTS, collectUnconditionalTailwindLiteralsFromCnArguments, forEachStringLiteralInClassExpression, isUnsafeLiteralForCnStyleApplySplit };

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

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