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

package/dist/lib/arrange/domain/source-text-formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-text-formatters.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/source-text-formatters.ts"],"names":[],"mappings":"AAEA,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,GACA,MAAM,CAaR;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAahG;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CASpD;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,GACrB,MAAM,CAQR"}

package/dist/lib/arrange/domain/source-text-formatters.js

@@ -0,0 +1,55 @@
+import { indentOfLineContaining } from "#lib/shared/source-code/domain/text-edit";
+export function escapeTsStringLiteralContent(group) {
+    return group.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+/**
+ * Multiline fragment for use *inside* an existing `cn(...)` — replaces one
+ * string argument with several, without producing `cn(cn(...))`.
+ */
+export function formatCnArguments(groups, options) {
+    const indent = options?.indent ?? "  ";
+    const commaAfterLast = options?.commaAfterLastGroup ?? options?.trailingClassName ?? false;
+    const lines = [];
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        const comma = i < groups.length - 1 || commaAfterLast ? "," : "";
+        lines.push(`${indent}"${escapeTsStringLiteralContent(group)}"${comma}`);
+    }
+    if (options?.trailingClassName) {
+        lines.push(`${indent}className,`);
+    }
+    return lines.join("\n");
+}
+export function formatCnCall(groups, options) {
+    const lines = ["cn("];
+    const commaOnEachStringLine = groups.length > 1 || Boolean(options?.trailingClassName);
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        const comma = commaOnEachStringLine ? "," : "";
+        lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+    }
+    if (options?.trailingClassName) {
+        lines.push("  className,");
+    }
+    lines.push(")");
+    return lines.join("\n");
+}
+export function formatArray(groups) {
+    const lines = ["["];
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        const comma = i < groups.length - 1 || groups.length > 1 ? "," : "";
+        lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+    }
+    lines.push("]");
+    return lines.join("\n");
+}
+export function formatJsxCnAttributeValue(groups, source, valueNodeStart) {
+    const baseIndent = indentOfLineContaining(source, valueNodeStart);
+    const argIndent = `${baseIndent}  `;
+    const cnArgumentsBlock = formatCnArguments(groups, {
+        indent: argIndent,
+        commaAfterLastGroup: groups.length > 1,
+    });
+    return `{cn(\n${cnArgumentsBlock}\n${baseIndent})}`;
+}

package/dist/lib/arrange/domain/tokenizer.d.ts

@@ -0,0 +1,45 @@
+import type { Bucket } from "#lib/arrange/domain/types";
+export declare function tokenizeClassString(classString: string): string[];
+/**
+ * Index of the first `:` that separates a Tailwind variant segment from the rest.
+ * Colons inside `[...]` (at positive bracket depth) are ignored so selectors like
+ * `[&_a:hover]:text-red-500` split as `[&_a:hover]:` + `text-red-500`.
+ */
+export declare function indexOfFirstVariantColon(text: string): number;
+export declare function stripVariants(token: string): string;
+/**
+ * Secondary sort inside the **composite** bucket: opacity / blend / isolation →
+ * 3D context → 3D transforms → 2D transforms → filters → will-change.
+ */
+export declare function compositeSecondaryOrder(bareUtility: string): number;
+/** Classify a **bare** utility (no `hover:` / `md:` / … prefixes). */
+export declare function classifyBareUtility(bareUtility: string): Bucket;
+/**
+ * Arbitrary **parent** selectors (`[&…]`, `[&>a]:…`, slot forms with `&` inside the bracket)
+ * scope utilities to descendants — bucket as `selector` so they chunk apart from base layout/typography
+ * and are labeled distinctly from interactive `state` variants (`hover:`, `data-[…]:`, …).
+ * Pure arbitrary **properties** (`[--x]:`, `[color:red]`) have no `&` in the leading `[…]` segment.
+ */
+export declare function isArbitraryParentSelectorStateToken(token: string): boolean;
+export declare function classifyToken(token: string): Bucket;
+/**
+ * Stable key for splitting adjacent `state` / `starting` tokens in {@link suggestCnGroups}
+ * (`selector` uses {@link selectorKey}).
+ * Uses the **full variant stack** (every `:` segment outside `[…]`), not only the
+ * outermost prefix, so `@md/foo:[&>*]:w-auto` and `@md/foo:has-[…]:mt-px` stay in
+ * separate groups while `hover:opacity` still keys as `hover` + `opacity`…
+ *
+ * `data-[…]` / `aria-[…]` normalize the first segment via {@link dataAttributeStem} /
+ * {@link ariaAttributeStem} (full token required for bracket capture).
+ */
+export declare function stateKey(token: string): string;
+/**
+ * Variant key for {@link Bucket} `"selector"` tokens in {@link suggestCnGroups}.
+ * Reuses {@link stateKey} layer splitting, then normalizes common shadcn/Radix SVG patterns so
+ * `[&_svg]:…` and `[&_svg:not([class*='size-'])]:…` stay in one chunk.
+ */
+export declare function selectorKey(token: string): string;
+export declare function bucketsCompatible(a: Bucket, b: Bucket): boolean;
+/** Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs. */
+export declare function bucketsMergeCompatible(a: Bucket, b: Bucket): boolean;
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/lib/arrange/domain/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/tokenizer.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AA4CxD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAa7D;AAMD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWnD;AA6FD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAiDnE;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAiK/D;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAa1E;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAmCnD;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAsB9C;AAID;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKjD;AASD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAK/D;AAED,8GAA8G;AAC9G,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAcpE"}

package/dist/lib/arrange/domain/tokenizer.js

@@ -0,0 +1,466 @@
+import { COMPATIBLE_BUCKET_SETS, MAX_STRIP_VARIANT_PASSES, RESPONSIVE_PREFIX, STATE_PREFIXES, } from "#lib/arrange/domain/constants";
+/**
+ * Variant stems not covered by a single entry in STATE_PREFIXES (compound `has-*`,
+ * numbered `nth-*`, media features, v4 `in-[…]`, child selectors `*` / `**`, …).
+ * When these are missed, `isStateToken` is false and the variant is stripped — the
+ * utility is then bucketed as if it were unconditional, which breaks preview grouping.
+ */
+function isCompoundOrMediaVariantPrefix(prefix) {
+    if (prefix === "*" || prefix === "**") {
+        return true;
+    }
+    if (prefix === "inert") {
+        return true;
+    }
+    if (prefix.startsWith("has-")) {
+        return true;
+    }
+    if (prefix.startsWith("in-[")) {
+        return true;
+    }
+    if (/^nth(?:-last)?(?:-of-type)?(?:-\d+|-\[)/.test(prefix) ||
+        /^nth-of-type-\d+$/.test(prefix) ||
+        /^nth-last-of-type-\d+$/.test(prefix)) {
+        return true;
+    }
+    if (/^(?:user-valid|user-invalid|contrast-more|contrast-less|forced-colors|inverted-colors)$/.test(prefix)) {
+        return true;
+    }
+    if (/^(?:any-)?pointer-(?:fine|coarse|none)$/.test(prefix)) {
+        return true;
+    }
+    if (/^(?:portrait|landscape|noscript)$/.test(prefix)) {
+        return true;
+    }
+    return false;
+}
+export function tokenizeClassString(classString) {
+    return classString.trim().split(/\s+/).filter(Boolean);
+}
+/**
+ * Index of the first `:` that separates a Tailwind variant segment from the rest.
+ * Colons inside `[...]` (at positive bracket depth) are ignored so selectors like
+ * `[&_a:hover]:text-red-500` split as `[&_a:hover]:` + `text-red-500`.
+ */
+export function indexOfFirstVariantColon(text) {
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "[") {
+            depth++;
+        }
+        else if (ch === "]") {
+            depth = Math.max(0, depth - 1);
+        }
+        else if (ch === ":" && depth === 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+// Strip all variant prefixes to get the bare utility name.
+// e.g. "hover:dark:md:text-sm" → "text-sm"
+// e.g. "@min-[600px]:flex" → "flex"
+// e.g. "[&_a:hover]:text-red-500" → "text-red-500"
+export function stripVariants(token) {
+    let withoutVariants = token;
+    const MAX_PASSES = MAX_STRIP_VARIANT_PASSES;
+    for (let i = 0; i < MAX_PASSES; i++) {
+        const colonIdx = indexOfFirstVariantColon(withoutVariants);
+        if (colonIdx === -1) {
+            break;
+        }
+        withoutVariants = withoutVariants.slice(colonIdx + 1);
+    }
+    return withoutVariants;
+}
+/** Outermost variant segment: first `:` at bracket depth 0 → text before it. */
+function firstLeadingVariantPrefix(token) {
+    const colonIdx = indexOfFirstVariantColon(token);
+    if (colonIdx === -1) {
+        return undefined;
+    }
+    return token.slice(0, colonIdx);
+}
+function isSelectorVariantToken(token) {
+    const prefix = firstLeadingVariantPrefix(token);
+    if (prefix === undefined) {
+        return false;
+    }
+    if (prefix === "*" || prefix === "**") {
+        return true;
+    }
+    if (prefix.startsWith("has-")) {
+        return true;
+    }
+    if (prefix.startsWith("in-[")) {
+        return true;
+    }
+    if (prefix.startsWith("group-[")) {
+        return true;
+    }
+    if (prefix.startsWith("peer-[")) {
+        return true;
+    }
+    if (prefix.startsWith("not-[")) {
+        return true;
+    }
+    return false;
+}
+function isStateToken(token) {
+    const prefix = firstLeadingVariantPrefix(token);
+    if (prefix === undefined) {
+        return false;
+    }
+    if (RESPONSIVE_PREFIX.test(token)) {
+        return true;
+    }
+    if (STATE_PREFIXES.has(prefix)) {
+        return true;
+    }
+    if (prefix.startsWith("data-[")) {
+        return true;
+    }
+    if (prefix.startsWith("aria-[")) {
+        return true;
+    }
+    if (prefix.startsWith("supports-[")) {
+        return true;
+    }
+    // Tailwind v4: style when inside an ancestor with matching `data-*` (e.g. `in-data-side-left:`,
+    // `in-data-[slot=tooltip-content]:`). The short stem `in` is in STATE_PREFIXES but outer
+    // prefixes are `in-data-…`, so they must be recognized explicitly.
+    if (prefix.startsWith("in-data-")) {
+        return true;
+    }
+    if (/^data-(?!\[)/.test(prefix)) {
+        return true;
+    }
+    if (/^aria-/.test(prefix)) {
+        return true;
+    }
+    if (/^(group|peer)-/.test(prefix)) {
+        return true;
+    }
+    if (/^not-/.test(prefix)) {
+        return true;
+    }
+    if (isCompoundOrMediaVariantPrefix(prefix)) {
+        return true;
+    }
+    if (prefix.startsWith("[") && prefix.endsWith("]")) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Secondary sort inside the **composite** bucket: opacity / blend / isolation →
+ * 3D context → 3D transforms → 2D transforms → filters → will-change.
+ */
+export function compositeSecondaryOrder(bareUtility) {
+    const b = bareUtility;
+    if (/^opacity(?:-|$)/.test(b) ||
+        /^mix-blend-/.test(b) ||
+        /^isolation(?:-|$)/.test(b) ||
+        b === "isolate") {
+        return 0;
+    }
+    if (b === "transform-3d" || /^perspective(?:-|$)/.test(b)) {
+        return 10;
+    }
+    if (/^rotate-[xyz](?:-|$)/.test(b) ||
+        /^translate-z(?:-|$)/.test(b) ||
+        /^scale-z(?:-|$)/.test(b)) {
+        return 20;
+    }
+    if (/^translate(?:-|$)/.test(b) ||
+        /^scale(?:-|$)/.test(b) ||
+        /^rotate(?:-|$)/.test(b) ||
+        /^skew(?:-|$)/.test(b)) {
+        return 30;
+    }
+    if (/^transform(?:-(?:gpu|cpu|none))?$/.test(b)) {
+        return 35;
+    }
+    if (/^blur(?:-|$)/.test(b) ||
+        /^backdrop-/.test(b) ||
+        /^filter(?:-|$)/.test(b) ||
+        /^brightness-/.test(b) ||
+        /^contrast-/.test(b) ||
+        /^grayscale(?:-|$)/.test(b) ||
+        /^hue-rotate-/.test(b) ||
+        /^invert(?:-|$)/.test(b) ||
+        /^saturate-/.test(b) ||
+        /^sepia(?:-|$)/.test(b)) {
+        return 40;
+    }
+    if (/^will-change/.test(b)) {
+        return 50;
+    }
+    return 99;
+}
+/** Classify a **bare** utility (no `hover:` / `md:` / … prefixes). */
+export function classifyBareUtility(bareUtility) {
+    const b = bareUtility;
+    // --- Existence: display roots, containment, named groups/peers ---
+    if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(b)) {
+        return "existence";
+    }
+    if (/^(?:hidden|contents|sr-only|not-sr-only|list-item|flow-root)$/.test(b) ||
+        /^(?:block|inline-block|inline)$/.test(b)) {
+        return "existence";
+    }
+    if (/^table(?:$|-)/.test(b)) {
+        return "existence";
+    }
+    if (/^contain-/.test(b)) {
+        return "existence";
+    }
+    if (/^(?:group|peer)(?:\/[a-z][a-z0-9-]*)?$/.test(b)) {
+        return "existence";
+    }
+    // --- Position ---
+    if (/^(?:static|relative|absolute|fixed|sticky)$/.test(b)) {
+        return "position";
+    }
+    if (/^-?(?:inset|top|right|bottom|left|start|end)(?:-|\/|$)/.test(b) ||
+        /^-?(?:inset-x|inset-y|inset-s|inset-e)-/.test(b)) {
+        return "position";
+    }
+    if (/^-?z-/.test(b) || b === "z-auto") {
+        return "position";
+    }
+    // --- Layout ---
+    if (/^(?:flex|inline-flex|grid|inline-grid|subgrid|masonry)(?:$|-)/.test(b) ||
+        /^(?:items|justify|justify-items|justify-self|content|self|place|place-content|place-items|place-self)-/.test(b) ||
+        /^-?(?:gap|space-[xy]|col-|row-|grid-|auto-cols|auto-rows|order-|order$)/.test(b) ||
+        /^-?(?:auto-flow|grid-flow)-/.test(b) ||
+        /^(?:columns-|break-after|break-before|break-inside)-/.test(b) ||
+        /^(?:float|clear)-/.test(b) ||
+        /^(?:wrap-|flex-wrap|flex-nowrap|flex-row|flex-col|flex-auto|flex-initial|flex-none|flex-1|flex-\[)/.test(b) ||
+        /^container$/.test(b)) {
+        return "layout";
+    }
+    // --- Sizing ---
+    if (/^-?(?:w|h|min-w|max-w|min-h|max-h|size|aspect|shrink|grow|basis)-/.test(b) ||
+        /^(?:shrink|grow)(?:$|-)/.test(b) ||
+        /^-?overflow-/.test(b) ||
+        /^-?object-/.test(b)) {
+        return "sizing";
+    }
+    // --- Spacing (margin / padding only; gap lives in layout) ---
+    if (/^-?(?:p|px|py|pt|pb|pl|pr|ps|pe|m|mx|my|mt|mb|ml|mr|ms|me)-/.test(b)) {
+        return "spacing";
+    }
+    // --- Shape & border (no `outline-*` — see Shadow; outline paints in the overlay pass) ---
+    if (/^-?(?:rounded|border|ring|divide|inset-ring)(?:-|\/|$)/.test(b) ||
+        /^(?:rounded|border|ring|divide|inset-ring)$/.test(b) ||
+        /^ring-offset-/.test(b)) {
+        return "shape";
+    }
+    // --- Background & fill ---
+    if (/^-?bg-/.test(b) ||
+        /^(?:from|via|to)(?:-|\/|$)/.test(b) ||
+        /^bg-(?:linear|radial|conic)-/.test(b) ||
+        /^-?mask-/.test(b) ||
+        /^-?(?:fill|stroke)-/.test(b)) {
+        return "background";
+    }
+    // --- Shadow & depth (includes `outline-*` — same paint phase as box-shadow overlay) ---
+    if (/^-?(?:shadow|inset-shadow|drop-shadow|text-shadow)(?:-|\/|$)/.test(b) ||
+        /^(?:shadow|inset-shadow)$/.test(b) ||
+        /^-?outline(?:-|\/|$)/.test(b) ||
+        /^outline$/.test(b)) {
+        return "shadow";
+    }
+    // --- Typography ---
+    if (/^-?(?:font|leading|tracking|list|indent|align|decoration|underline-offset|text-wrap|text-balance|text-pretty)-/.test(b) ||
+        /^-?(?:text-(?!shadow))/.test(b) ||
+        /^-?(?:whitespace|break|line-clamp|hyphens)-/.test(b) ||
+        /^(?:antialiased|subpixel-antialiased|italic|not-italic|overline|line-through|underline|no-underline|uppercase|lowercase|capitalize|normal-case|truncate|text-wrap|text-balance|text-pretty)$/.test(b) ||
+        /^text-wrap-/.test(b) ||
+        /^tabular-nums$|^slashed-zero$|^lining-nums$|^oldstyle-nums$|^proportional-nums$/.test(b)) {
+        return "typography";
+    }
+    // --- Composite & transforms (GPU / filter stack) ---
+    if (/^opacity(?:-|$)/.test(b) ||
+        /^mix-blend-/.test(b) ||
+        /^isolation(?:-|$)/.test(b) ||
+        b === "isolate" ||
+        /^transform(?:-(?:gpu|cpu|none))?$/.test(b) ||
+        /^-?(?:translate|scale|rotate|skew)-/.test(b) ||
+        /^perspective(?:-|$)/.test(b) ||
+        b === "transform-3d" ||
+        /^blur(?:-|$)/.test(b) ||
+        /^backdrop-/.test(b) ||
+        /^filter(?:-|$)/.test(b) ||
+        /^brightness-/.test(b) ||
+        /^contrast-/.test(b) ||
+        /^grayscale(?:-|$)/.test(b) ||
+        /^hue-rotate-/.test(b) ||
+        /^invert(?:-|$)/.test(b) ||
+        /^saturate-/.test(b) ||
+        /^sepia(?:-|$)/.test(b) ||
+        /^will-change/.test(b)) {
+        return "composite";
+    }
+    // --- Motion ---
+    if (/^(?:transition|duration|ease|delay|animate)(?:-|$)/.test(b) || /^ease-/.test(b)) {
+        return "motion";
+    }
+    // --- Behavior & interaction ---
+    if (/^(?:cursor|pointer-events|select|touch|scroll|scroll-m|scroll-p|overscroll|snap|resize|field-sizing|appearance|scheme|color-scheme|accent|caret)(?:-|$)/.test(b) ||
+        /^(?:cursor|select|resize)$/.test(b) ||
+        /^scroll-behavior/.test(b) ||
+        /^scroll-snap/.test(b) ||
+        /^touch-action/.test(b) ||
+        b === "inert") {
+        return "behavior";
+    }
+    return "other";
+}
+/**
+ * Arbitrary **parent** selectors (`[&…]`, `[&>a]:…`, slot forms with `&` inside the bracket)
+ * scope utilities to descendants — bucket as `selector` so they chunk apart from base layout/typography
+ * and are labeled distinctly from interactive `state` variants (`hover:`, `data-[…]:`, …).
+ * Pure arbitrary **properties** (`[--x]:`, `[color:red]`) have no `&` in the leading `[…]` segment.
+ */
+export function isArbitraryParentSelectorStateToken(token) {
+    if (/^\[&/.test(token)) {
+        return true;
+    }
+    if (!token.startsWith("[")) {
+        return false;
+    }
+    const colonIdx = indexOfFirstVariantColon(token);
+    if (colonIdx === -1 || colonIdx === 0 || token[colonIdx - 1] !== "]") {
+        return false;
+    }
+    const selector = token.slice(0, colonIdx);
+    return selector.includes("&");
+}
+export function classifyToken(token) {
+    // Before `[` arbitrary-property handling and `isStateToken`, parent-selector tokens must
+    // be `selector` so they flush into their own chunk after unconditional utilities.
+    if (isArbitraryParentSelectorStateToken(token)) {
+        return "selector";
+    }
+    if (isSelectorVariantToken(token)) {
+        return "selector";
+    }
+    if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(token)) {
+        return "existence";
+    }
+    if (token.startsWith("[")) {
+        const splitIdx = indexOfFirstVariantColon(token);
+        if (splitIdx === -1) {
+            return "arbitrary";
+        }
+        if (splitIdx === 0 || token[splitIdx - 1] !== "]") {
+            return "arbitrary";
+        }
+    }
+    const outer = firstLeadingVariantPrefix(token);
+    if (outer === "starting") {
+        return "starting";
+    }
+    if (isStateToken(token)) {
+        return "state";
+    }
+    const bareUtility = stripVariants(token);
+    return classifyBareUtility(bareUtility);
+}
+/**
+ * Stable key for `data-[…]` variants so unrelated selectors stay split, while
+ * **branching on the full bracket** (e.g. `data-[vaul-drawer-direction=bottom]`
+ * vs `=left`) keeps direction-specific utilities in separate state groups.
+ */
+function dataAttributeStem(token) {
+    const match = token.match(/^data-\[([^\]]*)\]/);
+    return match ? `data-[${match[1]}]` : "data";
+}
+/** Same idea as {@link dataAttributeStem} for `aria-[…]:` variants. */
+function ariaAttributeStem(token) {
+    const match = token.match(/^aria-\[([^\]]*)\]/);
+    return match ? `aria-[${match[1]}]` : "aria";
+}
+/** `in-data-[…]:` — normalize on the full bracket expression like {@link dataAttributeStem}. */
+function inDataAttributeStem(token) {
+    const match = token.match(/^in-data-\[([^\]]*)\]/);
+    return match ? `in-data-[${match[1]}]` : "in-data";
+}
+/**
+ * Stable key for splitting adjacent `state` / `starting` tokens in {@link suggestCnGroups}
+ * (`selector` uses {@link selectorKey}).
+ * Uses the **full variant stack** (every `:` segment outside `[…]`), not only the
+ * outermost prefix, so `@md/foo:[&>*]:w-auto` and `@md/foo:has-[…]:mt-px` stay in
+ * separate groups while `hover:opacity` still keys as `hover` + `opacity`…
+ *
+ * `data-[…]` / `aria-[…]` normalize the first segment via {@link dataAttributeStem} /
+ * {@link ariaAttributeStem} (full token required for bracket capture).
+ */
+export function stateKey(token) {
+    const layers = [];
+    let rest = token;
+    while (rest.length > 0) {
+        const colonIdx = indexOfFirstVariantColon(rest);
+        if (colonIdx === -1) {
+            break;
+        }
+        layers.push(rest.slice(0, colonIdx));
+        rest = rest.slice(colonIdx + 1);
+    }
+    if (layers.length === 0) {
+        return token;
+    }
+    if (layers[0].startsWith("data-[")) {
+        layers[0] = dataAttributeStem(token);
+    }
+    else if (layers[0].startsWith("aria-[")) {
+        layers[0] = ariaAttributeStem(token);
+    }
+    else if (layers[0].startsWith("in-data-[")) {
+        layers[0] = inDataAttributeStem(token);
+    }
+    return layers.join("\u001f");
+}
+const SELECTOR_KEY_SEP = "\u001f";
+/**
+ * Variant key for {@link Bucket} `"selector"` tokens in {@link suggestCnGroups}.
+ * Reuses {@link stateKey} layer splitting, then normalizes common shadcn/Radix SVG patterns so
+ * `[&_svg]:…` and `[&_svg:not([class*='size-'])]:…` stay in one chunk.
+ */
+export function selectorKey(token) {
+    return stateKey(token)
+        .split(SELECTOR_KEY_SEP)
+        .map(normalizeSelectorVariantLayer)
+        .join(SELECTOR_KEY_SEP);
+}
+function normalizeSelectorVariantLayer(layer) {
+    if (layer === "[&_svg:not([class*='size-'])]") {
+        return "[&_svg]";
+    }
+    return layer;
+}
+export function bucketsCompatible(a, b) {
+    if (a === b) {
+        return true;
+    }
+    return COMPATIBLE_BUCKET_SETS.some((bucketSet) => bucketSet.has(a) && bucketSet.has(b));
+}
+/** Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs. */
+export function bucketsMergeCompatible(a, b) {
+    if (a === "state" && b === "state") {
+        return false;
+    }
+    if (a === "starting" && b === "starting") {
+        return false;
+    }
+    if (a === "selector" && b === "selector") {
+        return false;
+    }
+    if (a === "arbitrary" || b === "arbitrary") {
+        return false;
+    }
+    return bucketsCompatible(a, b);
+}

package/dist/lib/arrange/domain/types.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Shared types for the arrange pipeline (Tailwind `cn()` / `tv()` tooling).
+ *
+ * Buckets follow a **render-pipeline order** (existence → … → conditions), aligned
+ * with Tailwind v4 utility groupings.
+ */
+import type { DomainAstNode, DomainCallExpression, DomainSourceFile, DomainTailwindClassLiteral } from "#lib/arrange/domain/ast/ast-node.model";
+export type Bucket = "existence" | "position" | "layout" | "sizing" | "spacing" | "shape" | "background" | "shadow" | "typography" | "composite" | "motion" | "starting" | "behavior"
+/** Selector variants (e.g. `[&…]:`, `*:`, `has-*`) distinct from interactive/data state. */
+ | "selector" | "state" | "arbitrary" | "other";
+/** String or no-substitution template literal used as a Tailwind class blob. */
+export type TailwindClassLiteral = DomainTailwindClassLiteral;
+export type ForEachStringLiteralInClassExpressionOptions = {
+    /**
+     * When `false`, do not visit literals inside `cond ? "a" : "b"`. Used when
+     * building the cn/tv **apply** pool so mutually exclusive branch classes are
+     * never merged into one static string (while `analyze` still uses the default).
+     */
+    descendIntoConditional?: boolean;
+};
+export type JsxClassNameStatic = {
+    lit: TailwindClassLiteral;
+    /** Replace this node: `StringLiteral` or whole `JsxExpression`. */
+    valueNode: DomainAstNode;
+};
+/**
+ * A StringNode represents a single "grouping slot" — the full set of static
+ * string literals that belong to one logical class surface.
+ */
+export type StringNode = {
+    /** All static string literals belonging to this slot, in source order. */
+    nodes: TailwindClassLiteral[];
+    sf: DomainSourceFile;
+    /** String slots in `tv({ ... })` that are not `cn(...)` arguments — use `formatArray`. */
+    isTvContext: boolean;
+    /** When set, the entire cn(...) call is replaced at once. */
+    cnCall?: DomainCallExpression;
+    /** First literal in the slot; used for positions and line-number reporting. */
+    get primaryClassLiteral(): TailwindClassLiteral;
+};
+export type GroupTarget = {
+    kind: "cnArg";
+    item: StringNode;
+} | {
+    kind: "jsxClassName";
+    sf: DomainSourceFile;
+    lit: TailwindClassLiteral;
+    valueNode: DomainAstNode;
+};
+export type PlannedGroupEdit = {
+    start: number;
+    end: number;
+    replacement: string;
+    /** Per-chunk bucket labels (same as `arrange group` trailing `// Buckets:` line). */
+    bucketSummary: string[];
+    jsxCn: boolean;
+    lineSf: DomainSourceFile;
+    reportNode: DomainAstNode;
+    label: string;
+};
+export type AnalyzeReport = {
+    files: number;
+    cnCallExpressions: number;
+    tvCallExpressions: number;
+    cnInsideTvCalls: Array<{
+        file: string;
+        line: number;
+        argCount: number;
+        preview: string;
+    }>;
+    longCnStringLiterals: Array<{
+        file: string;
+        line: number;
+        tokenCount: number;
+        preview: string;
+    }>;
+    longTvStringLiterals: Array<{
+        file: string;
+        line: number;
+        tokenCount: number;
+        preview: string;
+    }>;
+    longJsxClassNameLiterals: Array<{
+        file: string;
+        line: number;
+        tokenCount: number;
+        preview: string;
+    }>;
+};
+export type GroupFileResult = {
+    filePath: string;
+    /**
+     * Sites worth human review: applied edits plus `cn()` inside `tv` with no args
+     * (skipped). Matches preview totals when `groupEdits` correspond to the same plan.
+     */
+    totalFound: number;
+    /** Edits actually written in apply mode; always 0 in preview mode. */
+    changed: number;
+};
+export type ArrangeGroupFileOptions = {
+    write: boolean;
+    withClassName: boolean;
+    cnImport?: string;
+};
+export type ArrangeRunOnTargetOptions = ArrangeGroupFileOptions;
+export type ArrangeRunResult = {
+    filePaths: string[];
+    modifiedFiles: string[];
+    totalFound: number;
+    totalChanged: number;
+};
+//# sourceMappingURL=types.d.ts.map