@codefast/cli 0.3.5 → 0.3.12

package/README.md

@@ -1,125 +1,100 @@
-# Command `update-exports`
+# @codefast/cli
 
-## Tổng Quan
+Two tools bundled in one CLI:
 
-Command `update-exports` là một công cụ tự động hóa việc cập nhật cấu hình `exports` trong file `package.json` của các package trong dự án. Nó phân tích mã nguồn để xác định các module được export và tạo cấu trúc exports phù hợp.
+| Command       | Purpose                                                                                                                                                                             |
+| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mirror sync` | Regenerate `package.json` `exports` from each package's built `dist/` tree (pnpm workspace packages)                                                                                |
+| `arrange`     | Analyze, dry-run, or apply suggested grouping for long Tailwind class strings inside `cn()` / `tv()` call sites (Tailwind v4–oriented heuristics), or `group` a pasted class string |
 
-## Cách Sử Dụng
+---
 
-```shell script
-codefast update-exports [options]
-```
+## Requirements & Install
+
+**Node.js ≥ 24** is required.
 
-### Tùy Chọn
-
-| Tùy chọn                  | Mô tả                                            |
-| ------------------------- | ------------------------------------------------ |
-| `-p, --package <package>` | Lọc theo tên package cụ thể                      |
-| `-d, --dry-run`           | Chạy mà không thực hiện thay đổi (chỉ xem trước) |
-| `-v, --verbose`           | Hiển thị đầu ra chi tiết                         |
-| `-c, --config <path>`     | Đường dẫn đến file cấu hình tùy chỉnh            |
-
-## Luồng Hoạt Động
-
-```mermaid
-flowchart TD
-    A[Bắt đầu update-exports] --> B[processAllPackages]
-    B --> C[Tìm kiếm packages với findAllPackages]
-    C --> D[Lấy cấu hình với getConfig]
-    D --> E[Tìm tất cả package.json với glob]
-    E --> F{Đã tìm thấy packages?}
-    F -- Không --> G[Hiển thị cảnh báo]
-    G --> Z[Kết thúc]
-    F -- Có --> H[Xử lý từng package]
-    H --> I[processPackage cho từng package]
-    I --> J[Đọc package.json]
-    J --> K{Match với package filter?}
-    K -- Không --> L[Bỏ qua package]
-    K -- Có --> M[Phân tích imports với analyzeImports]
-    M --> N[Lưu kết quả phân tích]
-    N --> O[Tạo exports mới với generateExports]
-    O --> P{Dry run mode?}
-    P -- Có --> Q[Tạo preview exports]
-    Q --> Z
-    P -- Không --> R[Sao lưu package.json]
-    R --> S[Cập nhật package.json với exports mới]
-    S --> Z
+```bash
+# Global
+pnpm add -g @codefast/cli
+
+# Without a global install
+pnpm dlx @codefast/cli -- --help
 ```
 
-1. **Khởi tạo và Tìm Kiếm Package**
+---
 
-- Command đọc các tùy chọn từ người dùng
-- Tìm kiếm tất cả các file `package.json` trong workspace theo mẫu glob được cấu hình
+## `arrange`
 
-2. **Xử Lý Từng Package**
+### Recommended workflow
 
-- Kiểm tra xem package có khớp với filter hay không (nếu có)
-- Đọc cấu hình cụ thể cho package
-- Xác định đường dẫn đến file index
+1. **`analyze [target]`** — Prints a report (long strings, nested `cn` in `tv`, related notes). No files changed.
+2. **`preview [target]`** — Same transforms as `apply`, but writes nothing. Inspect stdout before touching the tree.
+3. **`apply [target]`** — Writes edits. Run `preview` first.
 
-3. **Phân Tích Imports**
+**Default target** (when path is omitted): `packages/ui/src/components` resolved from `process.cwd()`.
 
-- Sử dụng ts-morph để phân tích cú pháp của file index
-- Tìm tất cả các khai báo export
-- Chuẩn hóa đường dẫn (ví dụ: @/ thành ./)
-- Bỏ qua các import từ modules bên ngoài
-- Xử lý đường dẫn export theo cấu hình
+### Useful options
 
-4. **Tạo Exports Mới**
+- **`--with-class-name`** — Append `className` as the last argument to the suggested `cn(...)`.
+- **`--cn-import <spec>`** — Override the module specifier when the tool adds a `cn` import.
 
-- Dựa trên imports đã phân tích, tạo cấu trúc exports mới
-- So sánh với exports hiện tại
+### `group [tokens...]`
 
-5. **Lưu Thay Đổi**
+No filesystem involved — paste a class string, get back a suggested `cn(...)` (or a `tv()`-style array with `--tv`) plus a short buckets summary. Use this to tune your mental model before running `analyze` on a large tree.
 
-- Nếu ở chế độ dry-run:
-  - Tạo preview của exports mới mà không thực hiện thay đổi
-- Nếu không ở chế độ dry-run:
-  - Tạo bản sao lưu của package.json
-  - Cập nhật package.json với exports mới
+---
 
-6. **Báo Cáo Kết Quả**
+## Grouping philosophy — Render Pipeline Order
 
-- Hiển thị thống kê về số lượng package đã xử lý thành công, bỏ qua, thất bại
+`arrange` does **not** sort alphabetically. It groups utilities in roughly the same order the browser reasons about them:
 
-## Cấu Hình
+**Existence → Position → Layout → Sizing → Spacing → Shape → Background → Shadow → Typography → Composite → Motion → Starting → Behavior → Conditions (State)**
 
-Command `update-exports` sử dụng file cấu hình để xác định:
+Bucket breakdown:
 
-- Mẫu glob để tìm packages
-- Các prefix đường dẫn cần loại bỏ
-- Cấu hình cụ thể cho từng package
+| Bucket         | What it covers                                    | Examples                                          |
+| -------------- | ------------------------------------------------- | ------------------------------------------------- |
+| **Existence**  | Display / containment context                     | `hidden`, `block`, `@container`, `group`, `peer`  |
+| **Position**   | Where the box sits                                | `absolute`, `inset-*`, `top-*`, `z-*`             |
+| **Layout**     | How children flow                                 | `flex`, `grid`, `gap-*`, `items-*`                |
+| **Sizing**     | Box dimensions and overflow                       | `w-*`, `h-*`, `aspect-*`, `overflow-*`            |
+| **Spacing**    | Padding and margin only (gaps stay with Layout)   | `p-*`, `m-*`                                      |
+| **Shape**      | Corners and strokes                               | `rounded-*`, `border-*`, `ring-*`                 |
+| **Background** | Surfaces and masks                                | `bg-*`, `from-*`, `via-*`, `to-*`, `mask-*`       |
+| **Shadow**     | Depth                                             | `shadow-*`, `inset-shadow-*`, `text-shadow-*`     |
+| **Typography** | Text appearance                                   | `font-*`, `text-*`, `leading-*`                   |
+| **Composite**  | Layers and transforms — 3D context → 3D → 2D      | `opacity-*`, `rotate-x-*`, `translate-*`          |
+| **Motion**     | Time-based change                                 | `transition-*`, `animate-*`                       |
+| **Starting**   | Tailwind's `starting:` layer, kept next to Motion | `starting:*`                                      |
+| **Behavior**   | Input / scrolling / chrome                        | `cursor-*`, `scroll-*`, `field-sizing-*`, `inert` |
+| **State**      | Everything with a variant stack                   | `hover:`, `md:`, `@md/sidebar:`, `data-[…]:`      |
 
-Bạn có thể chỉ định file cấu hình tùy chỉnh bằng tùy chọn `-c, --config`.
+Some adjacent buckets may be merged into one string literal when declared _compatible_ (e.g. `layout` + `sizing`) — keeps `cn()` readable without flattening unrelated concerns.
 
-## Ví Dụ
+To change a placement, edit `classifyBareUtility` in `src/lib/arrange/tokenizer.ts` and add a `classifyToken` test in `src/lib/arrange.test.ts`.
 
-Cập nhật exports cho tất cả các package:
+---
 
-```shell script
-codefast update-exports
-```
+## `mirror sync`
 
-Chạy ở chế độ verbose để xem thông tin chi tiết:
+Run from anywhere under the monorepo — the CLI finds the root via `pnpm-workspace.yaml`.
 
-```shell script
-codefast update-exports --verbose
+```bash
+codefast mirror sync              # All workspace packages
+codefast mirror sync packages/ui  # One package only
+codefast mirror sync -v           # Verbose
 ```
 
-Chỉ xử lý một package cụ thể:
+**Config:** Place `codefast.config.js` (or `.mjs` / `.cjs` / `.json`) at repo root with a `mirror` object (`skipPackages`, `pathTransformations`, `customExports`, …).
 
-```shell script
-codefast update-exports --package @codefast/ui
-```
+> ⚠️ `.js`/`.mjs`/`.cjs` config files are loaded via `import()` — only run `mirror sync` in repositories you trust.
 
-Xem trước thay đổi mà không thực sự cập nhật:
+---
 
-```shell script
-codefast update-exports --dry-run
-```
+## Developing inside this monorepo
 
-## Lưu Ý
+```bash
+pnpm exec codefast --help
+```
 
-- Command sẽ tạo bản sao lưu của các file package.json trước khi thực hiện thay đổi
-- Các exports được tạo dựa trên việc phân tích mã nguồn, đảm bảo tính nhất quán
-- Sử dụng tùy chọn `--dry-run` để kiểm tra các thay đổi trước khi áp dụng
+Root `package.json` defines optional `cli:*` scripts (e.g. `cli:mirror-sync`, `cli:arrange-analyze`) as thin wrappers around `pnpm exec codefast …`.

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/bin.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { runCli } from "#program";
+const code = await runCli(process.argv);
+process.exit(code);

package/dist/commands/arrange.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function registerArrangeCommand(program: Command): void;
+//# sourceMappingURL=arrange.d.ts.map

package/dist/commands/arrange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange.d.ts","sourceRoot":"","sources":["../../src/commands/arrange.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4EzC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAsF7D"}

package/dist/commands/arrange.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+import process from "node:process";
+import { Option } from "commander";
+import { ArrangeError, ArrangeErrorCode, analyzeDirectory, createNodeCliFs, createNodeCliLogger, DEFAULT_ARRANGE_TARGET, formatArray, formatCnCall, printAnalyzeReport, runOnTarget, suggestCnGroups, summarizeGroupBucketLabels, } from "#lib/arrange";
+/** Commander attribute `withClassName` (second long flag `--with-class-name`). */
+function createWithClassNameOption() {
+    return new Option("--with-classname, --with-class-name", "Append className as final cn() argument").default(false);
+}
+function defaultTargetPath() {
+    return path.resolve(process.cwd(), DEFAULT_ARRANGE_TARGET);
+}
+function checkTargetExists(resolved, fs, logger) {
+    if (!fs.existsSync(resolved)) {
+        logger.err(`Not found: ${resolved}`);
+        process.exitCode = 1;
+        return false;
+    }
+    return true;
+}
+function handleArrangeLibError(e, logger) {
+    if (e instanceof ArrangeError && e.code === ArrangeErrorCode.TARGET_NOT_FOUND) {
+        logger.err(e.message);
+        process.exitCode = 1;
+        return true;
+    }
+    return false;
+}
+function runArrangeAction(resolvedTarget, runOpts, fs, logger) {
+    try {
+        runOnTarget(resolvedTarget, {
+            write: runOpts.write,
+            withClassName: !!runOpts.withClassName,
+            cnImport: runOpts.cnImport,
+        }, fs, logger);
+    }
+    catch (e) {
+        if (!handleArrangeLibError(e, logger))
+            throw e;
+    }
+}
+export function registerArrangeCommand(program) {
+    const arrange = program
+        .command("arrange")
+        .description("Analyze and regroup Tailwind classes in cn() / tv() calls (Tailwind v4)");
+    arrange
+        .command("analyze")
+        .description("Report long strings, nested cn in tv(), and related findings")
+        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
+        .action((target) => {
+        const fs = createNodeCliFs();
+        const logger = createNodeCliLogger();
+        const resolved = target ? path.resolve(target) : defaultTargetPath();
+        if (!checkTargetExists(resolved, fs, logger))
+            return;
+        printAnalyzeReport(resolved, analyzeDirectory(resolved, fs), logger);
+    });
+    arrange
+        .command("preview")
+        .description("Dry-run: print suggested replacements without writing files")
+        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
+        .addOption(createWithClassNameOption())
+        .option("--cn-import <spec>", "Override module specifier when adding cn import")
+        .action((target, opts) => {
+        const fs = createNodeCliFs();
+        const logger = createNodeCliLogger();
+        const resolved = target ? path.resolve(target) : defaultTargetPath();
+        if (!checkTargetExists(resolved, fs, logger))
+            return;
+        runArrangeAction(resolved, {
+            write: false,
+            withClassName: opts.withClassName,
+            cnImport: opts.cnImport,
+        }, fs, logger);
+    });
+    arrange
+        .command("apply")
+        .description("Apply grouping and cn-in-tv unwrap edits to files")
+        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
+        .addOption(createWithClassNameOption())
+        .option("--cn-import <spec>", "Override module specifier when adding cn import")
+        .action((target, opts) => {
+        const fs = createNodeCliFs();
+        const logger = createNodeCliLogger();
+        const resolved = target ? path.resolve(target) : defaultTargetPath();
+        if (!checkTargetExists(resolved, fs, logger))
+            return;
+        runArrangeAction(resolved, {
+            write: true,
+            withClassName: opts.withClassName,
+            cnImport: opts.cnImport,
+        }, fs, logger);
+    });
+    arrange
+        .command("group")
+        .description("Try grouping on a pasted class string (stdout: cn(...) or tv array with --tv)")
+        .argument("[tokens...]", "Class tokens (quote a single string if it contains spaces)")
+        .option("--tv", "Emit tv()-style array instead of cn() call", false)
+        .addOption(createWithClassNameOption())
+        .action((tokens, opts) => {
+        const inlineClasses = tokens.join(" ").trim();
+        if (!inlineClasses) {
+            process.stderr.write('Pass a class string. Example: codefast arrange group "flex gap-2 text-sm rounded-md"\n');
+            process.exitCode = 1;
+            return;
+        }
+        const groups = suggestCnGroups(inlineClasses);
+        const result = opts.tv
+            ? formatArray(groups)
+            : formatCnCall(groups, { trailingClassName: !!opts.withClassName });
+        process.stdout.write(`${result}\n`);
+        const bucketSummary = summarizeGroupBucketLabels(groups);
+        process.stdout.write(`\n// Buckets: ${JSON.stringify(bucketSummary)}\n`);
+    });
+}

package/dist/commands/mirror.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare function packageArgToRelative(rootDir: string, arg: string | undefined): string | undefined;
+export declare function registerMirrorCommand(program: Command): void;
+//# sourceMappingURL=mirror.d.ts.map

package/dist/commands/mirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mirror.d.ts","sourceRoot":"","sources":["../../src/commands/mirror.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAiBjG;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmC5D"}

package/dist/commands/mirror.js

@@ -0,0 +1,63 @@
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { createNodeCliFs } from "#lib/infra/node-io";
+import { normalizePath, runMirrorSync } from "#lib/mirror";
+import { findRepoRoot } from "#lib/repo-root";
+function tryRealpath(entryPath) {
+    try {
+        return realpathSync.native(entryPath);
+    }
+    catch {
+        return path.resolve(entryPath);
+    }
+}
+export function packageArgToRelative(rootDir, arg) {
+    if (!arg)
+        return undefined;
+    const rootReal = tryRealpath(path.resolve(rootDir));
+    const cwdReal = tryRealpath(process.cwd());
+    const resolved = path.isAbsolute(arg) ? path.resolve(arg) : path.resolve(cwdReal, arg);
+    const targetReal = tryRealpath(resolved);
+    const rel = path.relative(rootReal, targetReal);
+    const normalized = normalizePath(rel);
+    if (normalized.startsWith("..") ||
+        path.isAbsolute(normalized) ||
+        normalized === "" ||
+        normalized === ".") {
+        throw new Error(`Package path must be a subdirectory under monorepo root: ${rootDir}`);
+    }
+    return normalized;
+}
+export function registerMirrorCommand(program) {
+    const mirror = program
+        .command("mirror")
+        .description("Keep package manifests aligned with what you ship");
+    mirror
+        .command("sync")
+        .description("Write package.json exports from dist/ for workspace packages")
+        .argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)")
+        .option("-v, --verbose", "Print extra diagnostics", false)
+        .action(async function (pkg, options) {
+        const globals = this.optsWithGlobals();
+        const fs = createNodeCliFs();
+        const rootDir = findRepoRoot(fs);
+        let packageFilter;
+        try {
+            packageFilter = packageArgToRelative(rootDir, pkg);
+        }
+        catch (e) {
+            this.error(e instanceof Error ? e.message : String(e));
+            return;
+        }
+        const exitCode = await runMirrorSync({
+            rootDir,
+            verbose: options.verbose,
+            /** Commander sets `color: false` when `--no-color` is passed (default `color: true`). */
+            noColor: globals.color === false,
+            packageFilter,
+            fs,
+        });
+        process.exitCode = exitCode;
+    });
+}

package/dist/lib/arrange/analyze.d.ts

@@ -0,0 +1,4 @@
+import type { CliFs } from "#lib/infra/fs-contract";
+import type { AnalyzeReport } from "#lib/arrange/types";
+export declare function analyzeDirectory(target: string, fs: CliFs): AnalyzeReport;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/lib/arrange/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../src/lib/arrange/analyze.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AA8FxD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,GAAG,aAAa,CAsCzE"}

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