@codefast/cli 0.3.7-canary.0 → 0.3.12

package/dist/lib/arrange/analyze.js

@@ -0,0 +1,105 @@
+import ts from "typescript";
+import { LONG_STRING_TOKEN_THRESHOLD } from "#lib/arrange/constants";
+import { tokenizeClassString } from "#lib/arrange/tokenizer";
+import { forEachStringLiteralInClassExpression } from "#lib/arrange/ast/collectors-cn";
+import { jsxClassNameStaticLiteral } from "#lib/arrange/ast/collectors-jsx";
+import { collectCnCallsInsideTv, traverseTvObject } from "#lib/arrange/ast/collectors-tv";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, lineOf } from "#lib/arrange/ast/utils";
+import { walkTsxFiles } from "#lib/arrange/walk";
+function analyzeCnCall(sf, call, report) {
+    for (const arg of call.arguments) {
+        forEachStringLiteralInClassExpression(arg, (lit) => {
+            const text = lit.text;
+            const tokenCount = tokenizeClassString(text).length;
+            if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
+                report.longCnStringLiterals.push({
+                    file: sf.fileName,
+                    line: lineOf(sf, lit),
+                    tokenCount,
+                    preview: text.length > 72 ? `${text.slice(0, 72)}…` : text,
+                });
+            }
+        });
+    }
+}
+function visitCallExpressionForArrangeAnalyze(node, sf, sourceText, knownBindings, report) {
+    if (isCnOrTvIdentifier(node.expression, "cn", knownBindings)) {
+        report.cnCallExpressions++;
+        analyzeCnCall(sf, node, report);
+        return;
+    }
+    if (!isCnOrTvIdentifier(node.expression, "tv", knownBindings))
+        return;
+    report.tvCallExpressions++;
+    const arg0 = node.arguments[0];
+    if (!arg0 || !ts.isObjectLiteralExpression(arg0))
+        return;
+    for (const nestedCn of collectCnCallsInsideTv(sf, arg0, knownBindings, 0)) {
+        const src = sourceText.slice(nestedCn.getStart(sf), nestedCn.getEnd());
+        const preview = src.length > 72 ? `${src.slice(0, 72)}…` : src;
+        report.cnInsideTvCalls.push({
+            file: sf.fileName,
+            line: lineOf(sf, nestedCn),
+            argCount: nestedCn.arguments.length,
+            preview,
+        });
+    }
+    traverseTvObject(sf, arg0, (strNode) => {
+        const text = strNode.text;
+        const tokenCount = tokenizeClassString(text).length;
+        if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
+            report.longTvStringLiterals.push({
+                file: sf.fileName,
+                line: lineOf(sf, strNode),
+                tokenCount,
+                preview: text.length > 72 ? `${text.slice(0, 72)}…` : text,
+            });
+        }
+    }, 0, knownBindings);
+}
+function visitJsxAttributeForArrangeAnalyze(node, sf, filePath, report) {
+    if (!filePath.endsWith(".tsx"))
+        return;
+    const parsed = jsxClassNameStaticLiteral(node);
+    if (!parsed)
+        return;
+    const text = parsed.lit.text;
+    const tokenCount = tokenizeClassString(text).length;
+    if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
+        report.longJsxClassNameLiterals.push({
+            file: sf.fileName,
+            line: lineOf(sf, parsed.lit),
+            tokenCount,
+            preview: text.length > 72 ? `${text.slice(0, 72)}…` : text,
+        });
+    }
+}
+export function analyzeDirectory(target, fs) {
+    const report = {
+        files: 0,
+        cnCallExpressions: 0,
+        tvCallExpressions: 0,
+        cnInsideTvCalls: [],
+        longCnStringLiterals: [],
+        longTvStringLiterals: [],
+        longJsxClassNameLiterals: [],
+    };
+    const files = fs.statSync(target).isDirectory() ? walkTsxFiles(target, fs) : [target];
+    for (const filePath of files) {
+        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);
+        report.files++;
+        const knownBindings = buildKnownCnTvBindings(sf);
+        const visit = (node) => {
+            if (ts.isCallExpression(node)) {
+                visitCallExpressionForArrangeAnalyze(node, sf, sourceText, knownBindings, report);
+            }
+            if (ts.isJsxAttribute(node)) {
+                visitJsxAttributeForArrangeAnalyze(node, sf, filePath, report);
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sf);
+    }
+    return report;
+}

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

@@ -0,0 +1,10 @@
+import ts from "typescript";
+import type { ForEachStringLiteralInClassExpressionOptions, TailwindClassLiteral } from "#lib/arrange/types";
+export declare function forEachStringLiteralInClassExpression(expr: ts.Expression, sink: (node: TailwindClassLiteral) => void, depth?: number, options?: ForEachStringLiteralInClassExpressionOptions): void;
+export declare function isUnsafeLiteralForCnStyleApplySplit(node: TailwindClassLiteral): boolean;
+export declare const CN_APPLY_LITERAL_WALK_OPTS: ForEachStringLiteralInClassExpressionOptions;
+export declare function collectUnconditionalTailwindLiteralsFromCnArguments(args: ts.NodeArray<ts.Expression>): TailwindClassLiteral[];
+export declare function mergeCnUnconditionalLiteralPoolForTest(argsSnippet: string, options?: {
+    callee?: string;
+}): string;
+//# sourceMappingURL=collectors-cn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectors-cn.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/ast/collectors-cn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EACV,4CAA4C,EAC5C,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,IAAI,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI,EAC1C,KAAK,SAAI,EACT,OAAO,CAAC,EAAE,4CAA4C,GACrD,IAAI,CA4CN;AAED,wBAAgB,mCAAmC,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAEvF;AAED,eAAO,MAAM,0BAA0B,EAAE,4CAExC,CAAC;AAEF,wBAAgB,mDAAmD,CACjE,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,UAAU,CAAC,GAChC,oBAAoB,EAAE,CAqBxB;AAED,wBAAgB,sCAAsC,CACpD,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,MAAM,CAyBR"}

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

@@ -0,0 +1,84 @@
+import ts from "typescript";
+import { MAX_CLASS_EXPR_DEPTH } from "#lib/arrange/constants";
+export function forEachStringLiteralInClassExpression(expr, sink, depth = 0, options) {
+    if (depth > MAX_CLASS_EXPR_DEPTH)
+        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 el of expr.elements) {
+            if (ts.isSpreadElement(el))
+                continue;
+            forEachStringLiteralInClassExpression(el, sink, depth + 1, options);
+        }
+    }
+}
+export function isUnsafeLiteralForCnStyleApplySplit(node) {
+    return ts.isArrayLiteralExpression(node.parent);
+}
+export const CN_APPLY_LITERAL_WALK_OPTS = {
+    descendIntoConditional: false,
+};
+export 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;
+}
+export function mergeCnUnconditionalLiteralPoolForTest(argsSnippet, options) {
+    const callee = options?.callee ?? "cn";
+    const sourceText = `${callee}(${argsSnippet});`;
+    const sf = ts.createSourceFile("mergeCnUnconditionalLiteralPoolForTest.ts", sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const stmt = sf.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((n) => n.text)
+        .join(" ");
+}

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

@@ -0,0 +1,4 @@
+import ts from "typescript";
+import type { JsxClassNameStatic } from "#lib/arrange/types";
+export declare function jsxClassNameStaticLiteral(attr: ts.JsxAttribute): JsxClassNameStatic | undefined;
+//# sourceMappingURL=collectors-jsx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectors-jsx.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/ast/collectors-jsx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,GAAG,kBAAkB,GAAG,SAAS,CAe/F"}

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

@@ -0,0 +1,18 @@
+import ts from "typescript";
+export function jsxClassNameStaticLiteral(attr) {
+    if (!ts.isIdentifier(attr.name) || attr.name.text !== "className")
+        return undefined;
+    const init = attr.initializer;
+    if (!init)
+        return undefined;
+    if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
+        return { lit: init, valueNode: init };
+    }
+    if (ts.isJsxExpression(init) && init.expression) {
+        const innerExpr = init.expression;
+        if (ts.isStringLiteral(innerExpr) || ts.isNoSubstitutionTemplateLiteral(innerExpr)) {
+            return { lit: innerExpr, valueNode: init };
+        }
+    }
+    return undefined;
+}

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