@codefast/cli 0.3.13-canary.2 → 0.3.13-canary.4

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 };

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

@@ -0,0 +1,174 @@
+import "../constants.domain.mjs";
+import { forEachDomainChild, isDomainArrayLiteralExpression, isDomainCallExpression, isDomainObjectLiteralExpression, isDomainPropertyAssignment, isDomainSpreadElement, isDomainTailwindClassLiteral } from "./ast-node.model.mjs";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText } from "./ast-helpers.helper.mjs";
+import { CN_APPLY_LITERAL_WALK_OPTS, collectUnconditionalTailwindLiteralsFromCnArguments, forEachStringLiteralInClassExpression, isUnsafeLiteralForCnStyleApplySplit } from "./collectors-cn.collector.mjs";
+import { tokenizeClassString } from "../tokenizer.util.mjs";
+//#region src/lib/arrange/domain/ast/collectors-tv.collector.ts
+function traverseTvObject(sourceFile, obj, visitor, depth = 0, knownBindings) {
+	if (depth > 12) return;
+	for (const prop of obj.properties) {
+		if (!isDomainPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (isDomainTailwindClassLiteral(init)) visitor(init, sourceFile, void 0);
+		else if (isDomainArrayLiteralExpression(init)) for (const arrayElement of init.elements) {
+			if (isDomainSpreadElement(arrayElement)) continue;
+			if (isDomainTailwindClassLiteral(arrayElement)) visitor(arrayElement, sourceFile, void 0);
+			else if (isDomainCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) for (const arg of arrayElement.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+				visitor(lit, sourceFile, arrayElement);
+			});
+			else if (isDomainObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+				if (!isDomainPropertyAssignment(objectProperty)) continue;
+				const propName = propertyAssignmentNameText(objectProperty);
+				if (propName !== "className" && propName !== "class") continue;
+				const innerInit = objectProperty.initializer;
+				if (isDomainTailwindClassLiteral(innerInit)) visitor(innerInit, sourceFile, void 0);
+				else if (isDomainArrayLiteralExpression(innerInit)) for (const nestedArrayElement of innerInit.elements) {
+					if (isDomainSpreadElement(nestedArrayElement)) continue;
+					if (isDomainTailwindClassLiteral(nestedArrayElement)) visitor(nestedArrayElement, sourceFile, void 0);
+				}
+				else if (isDomainCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) for (const arg of innerInit.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+					visitor(lit, sourceFile, innerInit);
+				});
+			}
+		}
+		else if (isDomainObjectLiteralExpression(init)) traverseTvObject(sourceFile, init, visitor, depth + 1, knownBindings);
+		else if (isDomainCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) for (const arg of init.arguments) forEachStringLiteralInClassExpression(arg, (lit) => {
+			visitor(lit, sourceFile, init);
+		});
+	}
+}
+function collectCnCallsInsideTv(sourceFile, obj, knownBindings, depth = 0) {
+	if (depth > 12) return [];
+	const calls = [];
+	for (const prop of obj.properties) {
+		if (!isDomainPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (isDomainArrayLiteralExpression(init)) for (const arrayElement of init.elements) {
+			if (isDomainSpreadElement(arrayElement)) continue;
+			if (isDomainCallExpression(arrayElement) && isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) calls.push(arrayElement);
+			else if (isDomainObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+				if (!isDomainPropertyAssignment(objectProperty)) continue;
+				const propName = propertyAssignmentNameText(objectProperty);
+				if (propName !== "className" && propName !== "class") continue;
+				const innerInit = objectProperty.initializer;
+				if (isDomainCallExpression(innerInit) && isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) calls.push(innerInit);
+			}
+		}
+		else if (isDomainObjectLiteralExpression(init)) calls.push(...collectCnCallsInsideTv(sourceFile, init, knownBindings, depth + 1));
+		else if (isDomainCallExpression(init) && isCnOrTvIdentifier(init.expression, "cn", knownBindings)) calls.push(init);
+	}
+	return calls;
+}
+function listAllCnCallsInsideTvInSourceFile(sourceFile, knownBindings) {
+	const calls = [];
+	const visitSubtree = (tsNode) => {
+		if (isDomainCallExpression(tsNode) && isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+			const arg0 = tsNode.arguments[0];
+			if (arg0 && isDomainObjectLiteralExpression(arg0)) calls.push(...collectCnCallsInsideTv(sourceFile, arg0, knownBindings, 0));
+		}
+		forEachDomainChild(tsNode, visitSubtree);
+	};
+	for (const stmt of sourceFile.statements) visitSubtree(stmt);
+	return calls;
+}
+function makeStringNode(nodes, sourceFile, isTvContext, cnCall) {
+	return {
+		nodes,
+		sf: sourceFile,
+		isTvContext,
+		cnCall,
+		get primaryClassLiteral() {
+			const first = this.nodes[0];
+			if (first === void 0) throw new Error("invariant: StringNode requires at least one class literal");
+			return first;
+		}
+	};
+}
+function slotClassString(stringNode) {
+	return stringNode.nodes.map((literal) => literal.text).join(" ");
+}
+function emitTvSlot(lits, sourceFile, cnCall, results, seenNodePos) {
+	if (lits.length === 0) return;
+	const firstLit = lits[0];
+	if (firstLit === void 0) return;
+	const firstPos = firstLit.pos;
+	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, sourceFile, true, cnCall));
+}
+function collectTvSlots(sourceFile, obj, knownBindings, results, seenNodePos, depth = 0) {
+	if (depth > 12) return;
+	for (const prop of obj.properties) {
+		if (!isDomainPropertyAssignment(prop)) continue;
+		const init = prop.initializer;
+		if (isDomainTailwindClassLiteral(init)) emitTvSlot([init], sourceFile, void 0, results, seenNodePos);
+		else if (isDomainArrayLiteralExpression(init)) {
+			const arrayPos = init.pos;
+			if (seenNodePos.has(arrayPos)) continue;
+			seenNodePos.add(arrayPos);
+			const staticLits = [];
+			for (const arrayElement of init.elements) {
+				if (isDomainSpreadElement(arrayElement)) continue;
+				if (isDomainTailwindClassLiteral(arrayElement)) staticLits.push(arrayElement);
+				else if (isDomainCallExpression(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 (isDomainObjectLiteralExpression(arrayElement)) for (const objectProperty of arrayElement.properties) {
+					if (!isDomainPropertyAssignment(objectProperty)) continue;
+					const propName = propertyAssignmentNameText(objectProperty);
+					if (propName !== "className" && propName !== "class") continue;
+					const innerInit = objectProperty.initializer;
+					if (isDomainTailwindClassLiteral(innerInit)) emitTvSlot([innerInit], sourceFile, void 0, results, seenNodePos);
+					else if (isDomainArrayLiteralExpression(innerInit)) {
+						const innerLits = [];
+						for (const nestedArrayElement of innerInit.elements) if (!isDomainSpreadElement(nestedArrayElement) && isDomainTailwindClassLiteral(nestedArrayElement)) innerLits.push(nestedArrayElement);
+						emitTvSlot(innerLits, sourceFile, void 0, results, seenNodePos);
+					} else if (isDomainCallExpression(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, sourceFile, innerInit, results, seenNodePos);
+					}
+				}
+			}
+			if (staticLits.length > 0) emitTvSlot(staticLits, sourceFile, void 0, results, seenNodePos);
+		} else if (isDomainObjectLiteralExpression(init)) collectTvSlots(sourceFile, init, knownBindings, results, seenNodePos, depth + 1);
+		else if (isDomainCallExpression(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, sourceFile, init, results, seenNodePos);
+		}
+	}
+}
+function collectGroupableStringNodes(sourceFile) {
+	const results = [];
+	const seenNodePos = /* @__PURE__ */ new Set();
+	const knownBindings = buildKnownCnTvBindings(sourceFile);
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (isDomainCallExpression(tsNode)) {
+			if (isCnOrTvIdentifier(tsNode.expression, "cn", knownBindings)) {
+				const callPos = tsNode.pos;
+				if (seenNodePos.has(callPos)) {
+					forEachDomainChild(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, sourceFile, false, tsNode));
+			} else if (isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+				const arg0 = tsNode.arguments[0];
+				if (arg0 && isDomainObjectLiteralExpression(arg0)) collectTvSlots(sourceFile, arg0, knownBindings, results, seenNodePos);
+			}
+		}
+		forEachDomainChild(tsNode, visitTypeScriptSubtree);
+	};
+	for (const stmt of sourceFile.statements) visitTypeScriptSubtree(stmt);
+	return results;
+}
+//#endregion
+export { collectCnCallsInsideTv, collectGroupableStringNodes, collectTvSlots, emitTvSlot, listAllCnCallsInsideTvInSourceFile, makeStringNode, slotClassString, traverseTvObject };

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

@@ -0,0 +1,110 @@
+import "../constants.domain.mjs";
+import { indentOfLineContaining } from "../../../shared/source-code/domain/text-edit.model.mjs";
+import { forEachDomainChild, isDomainArrayLiteralExpression, isDomainJsxAttribute, isDomainTailwindClassLiteral } from "./ast-node.model.mjs";
+import { isUnsafeLiteralForCnStyleApplySplit } from "./collectors-cn.collector.mjs";
+import { tokenizeClassString } from "../tokenizer.util.mjs";
+import { collectGroupableStringNodes, slotClassString } from "./collectors-tv.collector.mjs";
+import { areCnTailwindPartitionsEquivalent, suggestCnGroups, summarizeGroupBucketLabels } from "../grouping.domain.mjs";
+import { escapeTsStringLiteralContent, formatArray, formatJsxCnAttributeValue } from "../source-text-formatters.formatter.mjs";
+import { jsxClassNameStaticLiteral } from "./collectors-jsx.collector.mjs";
+//#region src/lib/arrange/domain/ast/targets.model.ts
+function targetReplaceStart(target) {
+	if (target.kind === "cnArg") return target.item.cnCall ? target.item.cnCall.pos : target.item.primaryClassLiteral.pos;
+	return target.valueNode.pos;
+}
+function collectLongJsxClassNameTargets(sourceFile) {
+	const results = [];
+	const visitTypeScriptSubtree = (tsNode) => {
+		if (isDomainJsxAttribute(tsNode)) {
+			const parsed = jsxClassNameStaticLiteral(tsNode);
+			if (parsed && tokenizeClassString(parsed.lit.text).length >= 2) results.push({
+				kind: "jsxClassName",
+				sf: sourceFile,
+				lit: parsed.lit,
+				valueNode: parsed.valueNode
+			});
+		}
+		forEachDomainChild(tsNode, visitTypeScriptSubtree);
+	};
+	for (const stmt of sourceFile.statements) visitTypeScriptSubtree(stmt);
+	return results;
+}
+function collectGroupTargets(sourceFile, filePath) {
+	const cnPart = collectGroupableStringNodes(sourceFile).map((stringNode) => ({
+		kind: "cnArg",
+		item: stringNode
+	}));
+	if (!filePath.endsWith(".tsx")) return cnPart;
+	return [...cnPart, ...collectLongJsxClassNameTargets(sourceFile)];
+}
+function formatCnCallReplacement(stringNode, sourceText, withClassName) {
+	const call = stringNode.cnCall;
+	if (call === void 0) throw new Error("formatCnCallReplacement requires a cn() call on the string node");
+	const baseIndent = indentOfLineContaining(sourceText, call.pos);
+	const argIndent = `${baseIndent}  `;
+	const dynamicArgTexts = [];
+	for (const arg of call.arguments) if (!(isDomainTailwindClassLiteral(arg) && !isUnsafeLiteralForCnStyleApplySplit(arg))) dynamicArgTexts.push(sourceText.slice(arg.pos, arg.end));
+	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) {
+		const onlyGroup = groups[0];
+		if (onlyGroup === void 0) throw new Error("invariant: single cn group missing");
+		allArgs.push(`${argIndent}"${escapeTsStringLiteralContent(onlyGroup)}"`);
+	}
+	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.pos;
+		return {
+			start,
+			end: target.valueNode.end,
+			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 && anchorClassLiteral.parent !== null && isDomainArrayLiteralExpression(anchorClassLiteral.parent) ? anchorClassLiteral.parent : null;
+		const start = parentArray ? parentArray.pos : anchorClassLiteral.pos;
+		const end = parentArray ? parentArray.end : anchorClassLiteral.end;
+		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.pos,
+		end: call.end,
+		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 };