@codefast/cli 0.3.5 → 0.3.12

package/dist/lib/arrange/ast/collectors-tv.d.ts

@@ -0,0 +1,13 @@
+import ts from "typescript";
+import type { StringNode, TailwindClassLiteral } from "#lib/arrange/types";
+type StringNodeVisitor = (node: TailwindClassLiteral, sf: ts.SourceFile, cnCall?: ts.CallExpression) => void;
+export declare function traverseTvObject(sf: ts.SourceFile, obj: ts.ObjectLiteralExpression, visitor: StringNodeVisitor, depth?: number, knownBindings?: Set<string>): void;
+export declare function collectCnCallsInsideTv(sf: ts.SourceFile, obj: ts.ObjectLiteralExpression, knownBindings: Set<string>, depth?: number): ts.CallExpression[];
+export declare function listAllCnCallsInsideTvInSourceFile(sf: ts.SourceFile, knownBindings: Set<string>): ts.CallExpression[];
+export declare function makeStringNode(nodes: TailwindClassLiteral[], sf: ts.SourceFile, isTvContext: boolean, cnCall?: ts.CallExpression): StringNode;
+export declare function slotClassString(item: StringNode): string;
+export declare function emitTvSlot(lits: TailwindClassLiteral[], sf: ts.SourceFile, cnCall: ts.CallExpression | undefined, results: StringNode[], seenNodePos: Set<number>): void;
+export declare function collectTvSlots(sf: ts.SourceFile, obj: ts.ObjectLiteralExpression, knownBindings: Set<string>, results: StringNode[], seenNodePos: Set<number>, depth?: number): void;
+export declare function collectGroupableStringNodes(sf: ts.SourceFile): StringNode[];
+export {};
+//# sourceMappingURL=collectors-tv.d.ts.map

package/dist/lib/arrange/ast/collectors-tv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectors-tv.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/ast/collectors-tv.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAQ5B,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAQ3E,KAAK,iBAAiB,GAAG,CACvB,IAAI,EAAE,oBAAoB,EAC1B,EAAE,EAAE,EAAE,CAAC,UAAU,EACjB,MAAM,CAAC,EAAE,EAAE,CAAC,cAAc,KACvB,IAAI,CAAC;AAEV,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,EAAE,CAAC,UAAU,EACjB,GAAG,EAAE,EAAE,CAAC,uBAAuB,EAC/B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,SAAI,EACT,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC1B,IAAI,CA+DN;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,EAAE,CAAC,UAAU,EACjB,GAAG,EAAE,EAAE,CAAC,uBAAuB,EAC/B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,KAAK,SAAI,GACR,EAAE,CAAC,cAAc,EAAE,CAqCrB;AAED,wBAAgB,kCAAkC,CAChD,EAAE,EAAE,EAAE,CAAC,UAAU,EACjB,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,EAAE,CAAC,cAAc,EAAE,CAarB;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,oBAAoB,EAAE,EAC7B,EAAE,EAAE,EAAE,CAAC,UAAU,EACjB,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,EAAE,CAAC,cAAc,GACzB,UAAU,CAUZ;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAExD;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,oBAAoB,EAAE,EAC5B,EAAE,EAAE,EAAE,CAAC,UAAU,EACjB,MAAM,EAAE,EAAE,CAAC,cAAc,GAAG,SAAS,EACrC,OAAO,EAAE,UAAU,EAAE,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GACvB,IAAI,CASN;AAED,wBAAgB,cAAc,CAC5B,EAAE,EAAE,EAAE,CAAC,UAAU,EACjB,GAAG,EAAE,EAAE,CAAC,uBAAuB,EAC/B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,OAAO,EAAE,UAAU,EAAE,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,KAAK,SAAI,GACR,IAAI,CA+FN;AAED,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,GAAG,UAAU,EAAE,CAiC3E"}

package/dist/lib/arrange/ast/collectors-tv.js

@@ -0,0 +1,273 @@
+import ts from "typescript";
+import { APPLY_MIN_TOKENS, MAX_OBJECT_DEPTH } from "#lib/arrange/constants";
+import { CN_APPLY_LITERAL_WALK_OPTS, collectUnconditionalTailwindLiteralsFromCnArguments, forEachStringLiteralInClassExpression, isUnsafeLiteralForCnStyleApplySplit, } from "#lib/arrange/ast/collectors-cn";
+import { tokenizeClassString } from "#lib/arrange/tokenizer";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText, } from "#lib/arrange/ast/utils";
+export function traverseTvObject(sf, obj, visitor, depth = 0, knownBindings) {
+    if (depth > MAX_OBJECT_DEPTH)
+        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, undefined);
+        }
+        else if (ts.isArrayLiteralExpression(init)) {
+            for (const el of init.elements) {
+                if (ts.isSpreadElement(el))
+                    continue;
+                if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) {
+                    visitor(el, sf, undefined);
+                }
+                else if (ts.isCallExpression(el) &&
+                    isCnOrTvIdentifier(el.expression, "cn", knownBindings)) {
+                    for (const arg of el.arguments) {
+                        forEachStringLiteralInClassExpression(arg, (lit) => {
+                            visitor(lit, sf, el);
+                        });
+                    }
+                }
+                else if (ts.isObjectLiteralExpression(el)) {
+                    for (const inner of el.properties) {
+                        if (!ts.isPropertyAssignment(inner))
+                            continue;
+                        const propName = propertyAssignmentNameText(inner);
+                        if (propName !== "className" && propName !== "class")
+                            continue;
+                        const innerInit = inner.initializer;
+                        if (ts.isStringLiteral(innerInit) || ts.isNoSubstitutionTemplateLiteral(innerInit)) {
+                            visitor(innerInit, sf, undefined);
+                        }
+                        else if (ts.isArrayLiteralExpression(innerInit)) {
+                            for (const innerEl of innerInit.elements) {
+                                if (ts.isSpreadElement(innerEl))
+                                    continue;
+                                if (ts.isStringLiteral(innerEl) || ts.isNoSubstitutionTemplateLiteral(innerEl)) {
+                                    visitor(innerEl, sf, undefined);
+                                }
+                            }
+                        }
+                        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);
+                });
+            }
+        }
+    }
+}
+export function collectCnCallsInsideTv(sf, obj, knownBindings, depth = 0) {
+    if (depth > MAX_OBJECT_DEPTH)
+        return [];
+    const calls = [];
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const init = prop.initializer;
+        if (ts.isArrayLiteralExpression(init)) {
+            for (const el of init.elements) {
+                if (ts.isSpreadElement(el))
+                    continue;
+                if (ts.isCallExpression(el) && isCnOrTvIdentifier(el.expression, "cn", knownBindings)) {
+                    calls.push(el);
+                }
+                else if (ts.isObjectLiteralExpression(el)) {
+                    for (const inner of el.properties) {
+                        if (!ts.isPropertyAssignment(inner))
+                            continue;
+                        const propName = propertyAssignmentNameText(inner);
+                        if (propName !== "className" && propName !== "class")
+                            continue;
+                        const innerInit = inner.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;
+}
+export function listAllCnCallsInsideTvInSourceFile(sf, knownBindings) {
+    const calls = [];
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && isCnOrTvIdentifier(node.expression, "tv", knownBindings)) {
+            const arg0 = node.arguments[0];
+            if (arg0 && ts.isObjectLiteralExpression(arg0)) {
+                calls.push(...collectCnCallsInsideTv(sf, arg0, knownBindings, 0));
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return calls;
+}
+export function makeStringNode(nodes, sf, isTvContext, cnCall) {
+    return {
+        nodes,
+        sf,
+        isTvContext,
+        cnCall,
+        get node() {
+            return this.nodes[0];
+        },
+    };
+}
+export function slotClassString(item) {
+    return item.nodes.map((n) => n.text).join(" ");
+}
+export 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);
+    const totalTokens = lits.reduce((s, n) => s + tokenizeClassString(n.text).length, 0);
+    if (totalTokens < APPLY_MIN_TOKENS)
+        return;
+    results.push(makeStringNode(lits, sf, true, cnCall));
+}
+export function collectTvSlots(sf, obj, knownBindings, results, seenNodePos, depth = 0) {
+    if (depth > MAX_OBJECT_DEPTH)
+        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, undefined, results, seenNodePos);
+        }
+        else if (ts.isArrayLiteralExpression(init)) {
+            const arrayPos = init.getStart(sf);
+            if (seenNodePos.has(arrayPos))
+                continue;
+            seenNodePos.add(arrayPos);
+            const staticLits = [];
+            for (const el of init.elements) {
+                if (ts.isSpreadElement(el))
+                    continue;
+                if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) {
+                    staticLits.push(el);
+                }
+                else if (ts.isCallExpression(el) &&
+                    isCnOrTvIdentifier(el.expression, "cn", knownBindings)) {
+                    for (const arg of el.arguments) {
+                        forEachStringLiteralInClassExpression(arg, (lit) => {
+                            if (!isUnsafeLiteralForCnStyleApplySplit(lit))
+                                staticLits.push(lit);
+                        }, 0, CN_APPLY_LITERAL_WALK_OPTS);
+                    }
+                }
+                else if (ts.isObjectLiteralExpression(el)) {
+                    for (const inner of el.properties) {
+                        if (!ts.isPropertyAssignment(inner))
+                            continue;
+                        const propName = propertyAssignmentNameText(inner);
+                        if (propName !== "className" && propName !== "class")
+                            continue;
+                        const innerInit = inner.initializer;
+                        if (ts.isStringLiteral(innerInit) || ts.isNoSubstitutionTemplateLiteral(innerInit)) {
+                            emitTvSlot([innerInit], sf, undefined, results, seenNodePos);
+                        }
+                        else if (ts.isArrayLiteralExpression(innerInit)) {
+                            const innerLits = [];
+                            for (const innerEl of innerInit.elements) {
+                                if (!ts.isSpreadElement(innerEl) &&
+                                    (ts.isStringLiteral(innerEl) || ts.isNoSubstitutionTemplateLiteral(innerEl))) {
+                                    innerLits.push(innerEl);
+                                }
+                            }
+                            emitTvSlot(innerLits, sf, undefined, 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, undefined, 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);
+        }
+    }
+}
+export function collectGroupableStringNodes(sf) {
+    const results = [];
+    const seenNodePos = new Set();
+    const knownBindings = buildKnownCnTvBindings(sf);
+    const visit = (node) => {
+        if (ts.isCallExpression(node)) {
+            if (isCnOrTvIdentifier(node.expression, "cn", knownBindings)) {
+                const callPos = node.getStart(sf);
+                if (seenNodePos.has(callPos)) {
+                    ts.forEachChild(node, visit);
+                    return;
+                }
+                seenNodePos.add(callPos);
+                const staticLits = collectUnconditionalTailwindLiteralsFromCnArguments(node.arguments);
+                const totalTokens = staticLits.reduce((s, n) => s + tokenizeClassString(n.text).length, 0);
+                if (staticLits.length > 0 && totalTokens >= APPLY_MIN_TOKENS) {
+                    results.push(makeStringNode(staticLits, sf, false, node));
+                }
+            }
+            else if (isCnOrTvIdentifier(node.expression, "tv", knownBindings)) {
+                const arg0 = node.arguments[0];
+                if (arg0 && ts.isObjectLiteralExpression(arg0)) {
+                    collectTvSlots(sf, arg0, knownBindings, results, seenNodePos);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return results;
+}

package/dist/lib/arrange/ast/targets.d.ts

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import type { GroupTarget, PlannedGroupEdit, StringNode } from "#lib/arrange/types";
+export declare function targetReplaceStart(target: GroupTarget): number;
+export declare function collectLongJsxClassNameTargets(sf: ts.SourceFile): GroupTarget[];
+export declare function collectGroupTargets(sf: ts.SourceFile, filePath: string): GroupTarget[];
+export declare function formatCnCallReplacement(item: StringNode, sourceText: string, withClassName: boolean): string;
+export declare function planGroupEditForTarget(target: GroupTarget, textAfterUnwrap: string, withClassName: boolean): PlannedGroupEdit | undefined;
+//# sourceMappingURL=targets.d.ts.map

package/dist/lib/arrange/ast/targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/ast/targets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAY5B,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAOpF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAO9D;AAED,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,GAAG,WAAW,EAAE,CAkB/E;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE,CAItF;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,OAAO,GACrB,MAAM,CA2CR;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,WAAW,EACnB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,OAAO,GACrB,gBAAgB,GAAG,SAAS,CAyE9B"}

package/dist/lib/arrange/ast/targets.js

@@ -0,0 +1,143 @@
+import ts from "typescript";
+import { APPLY_MIN_TOKENS } from "#lib/arrange/constants";
+import { areCnTailwindPartitionsEquivalent, suggestCnGroups, summarizeGroupBucketLabels, } from "#lib/arrange/grouping";
+import { escapeTsStringLiteralContent, formatArray, formatJsxCnAttributeValue, } from "#lib/arrange/formatters";
+import { tokenizeClassString } from "#lib/arrange/tokenizer";
+import { isUnsafeLiteralForCnStyleApplySplit } from "#lib/arrange/ast/collectors-cn";
+import { jsxClassNameStaticLiteral } from "#lib/arrange/ast/collectors-jsx";
+import { collectGroupableStringNodes, slotClassString } from "#lib/arrange/ast/collectors-tv";
+import { indentOfLineContaining } from "#lib/arrange/ast/utils";
+export function targetReplaceStart(target) {
+    if (target.kind === "cnArg") {
+        return target.item.cnCall
+            ? target.item.cnCall.getStart(target.item.sf)
+            : target.item.node.getStart(target.item.sf);
+    }
+    return target.valueNode.getStart(target.sf);
+}
+export function collectLongJsxClassNameTargets(sf) {
+    const results = [];
+    const visit = (node) => {
+        if (ts.isJsxAttribute(node)) {
+            const parsed = jsxClassNameStaticLiteral(node);
+            if (parsed && tokenizeClassString(parsed.lit.text).length >= APPLY_MIN_TOKENS) {
+                results.push({
+                    kind: "jsxClassName",
+                    sf,
+                    lit: parsed.lit,
+                    valueNode: parsed.valueNode,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return results;
+}
+export function collectGroupTargets(sf, filePath) {
+    const cnPart = collectGroupableStringNodes(sf).map((item) => ({ kind: "cnArg", item }));
+    if (!filePath.endsWith(".tsx"))
+        return cnPart;
+    return [...cnPart, ...collectLongJsxClassNameTargets(sf)];
+}
+export function formatCnCallReplacement(item, sourceText, withClassName) {
+    const call = item.cnCall;
+    const sf = item.sf;
+    const baseIndent = indentOfLineContaining(sourceText, call.getStart(sf));
+    const argIndent = `${baseIndent}  `;
+    const dynamicArgTexts = [];
+    for (const arg of call.arguments) {
+        const isSimpleStatic = (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) &&
+            !isUnsafeLiteralForCnStyleApplySplit(arg);
+        if (!isSimpleStatic) {
+            dynamicArgTexts.push(sourceText.slice(arg.getStart(sf), arg.getEnd()));
+        }
+    }
+    const pool = slotClassString(item);
+    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 dyn of dynamicArgTexts) {
+        allArgs.push(`${argIndent}${dyn}`);
+    }
+    if (withClassName) {
+        allArgs.push(`${argIndent}className`);
+    }
+    // Keep formatter behavior explicit: multiline cn() calls with multiple args use trailing comma.
+    const commaAfterLastArg = allArgs.length > 1;
+    const argLines = allArgs.map((argLine, lineIndex) => lineIndex < allArgs.length - 1 || commaAfterLastArg ? `${argLine},` : `${argLine}`);
+    return `cn(\n${argLines.join("\n")}\n${baseIndent})`;
+}
+export function planGroupEditForTarget(target, textAfterUnwrap, withClassName) {
+    if (target.kind === "jsxClassName") {
+        const groups = suggestCnGroups(target.lit.text);
+        if (groups.length <= 1)
+            return undefined;
+        const start = target.valueNode.getStart(target.sf);
+        const end = target.valueNode.getEnd();
+        const replacement = formatJsxCnAttributeValue(groups, textAfterUnwrap, start);
+        return {
+            start,
+            end,
+            replacement,
+            bucketSummary: summarizeGroupBucketLabels(groups),
+            jsxCn: true,
+            lineSf: target.sf,
+            reportNode: target.lit,
+            label: "JSX className",
+        };
+    }
+    const pool = slotClassString(target.item);
+    const groups = suggestCnGroups(pool);
+    if (groups.length <= 1)
+        return undefined;
+    if (areCnTailwindPartitionsEquivalent(target.item.nodes.map((node) => node.text), groups)) {
+        return undefined;
+    }
+    if (!target.item.cnCall) {
+        const firstNode = target.item.node;
+        const parentArray = target.item.nodes.length > 1 && ts.isArrayLiteralExpression(firstNode.parent)
+            ? firstNode.parent
+            : null;
+        const start = parentArray
+            ? parentArray.getStart(target.item.sf)
+            : firstNode.getStart(target.item.sf);
+        const end = parentArray ? parentArray.getEnd() : firstNode.getEnd();
+        const baseIndent = indentOfLineContaining(textAfterUnwrap, start);
+        const replacement = formatArray(groups)
+            .split("\n")
+            .map((line, lineIndex) => (lineIndex === 0 ? line : `${baseIndent}${line}`))
+            .join("\n");
+        return {
+            start,
+            end,
+            replacement,
+            bucketSummary: summarizeGroupBucketLabels(groups),
+            jsxCn: false,
+            lineSf: target.item.sf,
+            reportNode: firstNode,
+            label: target.item.isTvContext ? "tv" : "cn",
+        };
+    }
+    const call = target.item.cnCall;
+    const start = call.getStart(target.item.sf);
+    const end = call.getEnd();
+    const replacement = formatCnCallReplacement(target.item, textAfterUnwrap, withClassName);
+    return {
+        start,
+        end,
+        replacement,
+        bucketSummary: summarizeGroupBucketLabels(groups),
+        jsxCn: false,
+        lineSf: target.item.sf,
+        reportNode: target.item.node,
+        label: target.item.isTvContext ? "tv" : "cn",
+    };
+}

package/dist/lib/arrange/ast/utils.d.ts

@@ -0,0 +1,36 @@
+import ts from "typescript";
+/** Known module specifiers that export `cn` / `tv`. */
+export declare const KNOWN_CN_TV_MODULES: Set<string>;
+/**
+ * True for typical shadcn-style re-exports: `./utils`, `@/lib/utils`, `…/utils/…`,
+ * or a dedicated `cn.ts` / `cn.tsx` module.
+ */
+export declare function moduleLooksLikeCnTvReexport(mod: string): boolean;
+/**
+ * Build a set of local binding names that are imported from a known cn/tv
+ * module in `sf`.
+ */
+export declare function buildKnownCnTvBindings(sf: ts.SourceFile): Set<string>;
+/**
+ * Returns true when `expr` is an identifier whose name matches `name` AND
+ * that name is listed in `knownBindings` from a recognized import.
+ */
+export declare function isCnOrTvIdentifier(expr: ts.Expression, name: "cn" | "tv", knownBindings?: Set<string>): boolean;
+export declare function propertyAssignmentNameText(prop: ts.PropertyAssignment): string | undefined;
+export declare function lineOf(sf: ts.SourceFile, node: ts.Node): number;
+/**
+ * Returns only the leading whitespace (tabs / spaces) of the line containing
+ * `pos`.
+ */
+export declare function indentOfLineContaining(source: string, pos: number): string;
+export declare function applyEditsDescending(sourceText: string, edits: ReadonlyArray<{
+    start: number;
+    end: number;
+    replacement: string;
+}>): string;
+/**
+ * Replace `cn(...)` nested in `tv({...})` with a plain string (one arg) or a string
+ * array (multiple args). Returns undefined when there are zero arguments.
+ */
+export declare function unwrapCnInsideTvCallReplacement(call: ts.CallExpression, sourceText: string, sf: ts.SourceFile): string | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/arrange/ast/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/ast/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,uDAAuD;AACvD,eAAO,MAAM,mBAAmB,aAU9B,CAAC;AAEH;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAMhE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,CAqBrE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,IAAI,EAAE,IAAI,GAAG,IAAI,EACjB,aAAa,GAAE,GAAG,CAAC,MAAM,CAAwB,GAChD,OAAO,CAOT;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,EAAE,CAAC,kBAAkB,GAAG,MAAM,GAAG,SAAS,CAI1F;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAE/D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAoB1E;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,aAAa,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,GACxE,MAAM,CAOR;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,EAAE,CAAC,cAAc,EACvB,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,EAAE,CAAC,UAAU,GAChB,MAAM,GAAG,SAAS,CAoBpB"}

package/dist/lib/arrange/ast/utils.js

@@ -0,0 +1,138 @@
+import ts from "typescript";
+import { EMPTY_CN_TV_BINDINGS } from "#lib/arrange/constants";
+/** Known module specifiers that export `cn` / `tv`. */
+export const KNOWN_CN_TV_MODULES = new Set([
+    "@codefast/tailwind-variants",
+    "clsx",
+    "class-variance-authority",
+    // Backward compatibility only: keep detection for existing user code that still imports
+    // from "tailwind-variants"; new code should prefer "@codefast/tailwind-variants".
+    "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.
+ */
+export function moduleLooksLikeCnTvReexport(mod) {
+    const norm = mod.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`.
+ */
+export function buildKnownCnTvBindings(sf) {
+    const bindings = 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 mod = spec.text;
+        const isKnown = KNOWN_CN_TV_MODULES.has(mod);
+        if (!isKnown && !moduleLooksLikeCnTvReexport(mod))
+            continue;
+        const clause = stmt.importClause;
+        if (clause.name)
+            bindings.add(clause.name.text);
+        if (!clause.namedBindings)
+            continue;
+        if (ts.isNamedImports(clause.namedBindings)) {
+            for (const el of clause.namedBindings.elements)
+                bindings.add(el.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.
+ */
+export 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;
+}
+export function propertyAssignmentNameText(prop) {
+    if (ts.isIdentifier(prop.name))
+        return prop.name.text;
+    if (ts.isStringLiteral(prop.name))
+        return prop.name.text;
+    return undefined;
+}
+export function lineOf(sf, node) {
+    return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+}
+/**
+ * Returns only the leading whitespace (tabs / spaces) of the line containing
+ * `pos`.
+ */
+export 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);
+    const indentMatch = /^[\t ]*/.exec(line);
+    return indentMatch?.[0] ?? "";
+}
+export 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.
+ */
+export function unwrapCnInsideTvCallReplacement(call, sourceText, sf) {
+    const args = call.arguments;
+    if (args.length === 0)
+        return undefined;
+    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());
+        // Trailing comma on every element — intentional (Prettier-compatible style;
+        // keeps array diffs clean when arguments are later added or removed).
+        const comma = i < args.length - 1 || args.length > 1 ? "," : "";
+        lines.push(`${innerIndent}${piece}${comma}`);
+    }
+    lines.push(`${baseIndent}]`);
+    return lines.join("\n");
+}