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

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

@@ -0,0 +1,302 @@
+import { APPLY_MIN_TOKENS, MAX_OBJECT_DEPTH } from "#lib/arrange/domain/constants";
+import { isDomainArrayLiteralExpression, isDomainCallExpression, isDomainObjectLiteralExpression, isDomainPropertyAssignment, isDomainSpreadElement, isDomainTailwindClassLiteral, forEachDomainChild, } from "#lib/arrange/domain/ast/ast-node.model";
+import { CN_APPLY_LITERAL_WALK_OPTS, collectUnconditionalTailwindLiteralsFromCnArguments, forEachStringLiteralInClassExpression, isUnsafeLiteralForCnStyleApplySplit, } from "#lib/arrange/domain/ast/collectors-cn";
+import { tokenizeClassString } from "#lib/arrange/domain/tokenizer";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText, } from "#lib/arrange/domain/ast/ast-helpers";
+export function traverseTvObject(sourceFile, obj, visitor, depth = 0, knownBindings) {
+    if (depth > MAX_OBJECT_DEPTH) {
+        return;
+    }
+    for (const prop of obj.properties) {
+        if (!isDomainPropertyAssignment(prop)) {
+            continue;
+        }
+        const init = prop.initializer;
+        if (isDomainTailwindClassLiteral(init)) {
+            visitor(init, sourceFile, undefined);
+        }
+        else if (isDomainArrayLiteralExpression(init)) {
+            for (const arrayElement of init.elements) {
+                if (isDomainSpreadElement(arrayElement)) {
+                    continue;
+                }
+                if (isDomainTailwindClassLiteral(arrayElement)) {
+                    visitor(arrayElement, sourceFile, undefined);
+                }
+                else if (isDomainCallExpression(arrayElement) &&
+                    isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) {
+                    for (const arg of arrayElement.arguments) {
+                        forEachStringLiteralInClassExpression(arg, (lit) => {
+                            visitor(lit, sourceFile, arrayElement);
+                        });
+                    }
+                }
+                else if (isDomainObjectLiteralExpression(arrayElement)) {
+                    for (const objectProperty of arrayElement.properties) {
+                        if (!isDomainPropertyAssignment(objectProperty)) {
+                            continue;
+                        }
+                        const propName = propertyAssignmentNameText(objectProperty);
+                        if (propName !== "className" && propName !== "class") {
+                            continue;
+                        }
+                        const innerInit = objectProperty.initializer;
+                        if (isDomainTailwindClassLiteral(innerInit)) {
+                            visitor(innerInit, sourceFile, undefined);
+                        }
+                        else if (isDomainArrayLiteralExpression(innerInit)) {
+                            for (const nestedArrayElement of innerInit.elements) {
+                                if (isDomainSpreadElement(nestedArrayElement)) {
+                                    continue;
+                                }
+                                if (isDomainTailwindClassLiteral(nestedArrayElement)) {
+                                    visitor(nestedArrayElement, sourceFile, undefined);
+                                }
+                            }
+                        }
+                        else if (isDomainCallExpression(innerInit) &&
+                            isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
+                            for (const arg of innerInit.arguments) {
+                                forEachStringLiteralInClassExpression(arg, (lit) => {
+                                    visitor(lit, sourceFile, innerInit);
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else if (isDomainObjectLiteralExpression(init)) {
+            traverseTvObject(sourceFile, init, visitor, depth + 1, knownBindings);
+        }
+        else if (isDomainCallExpression(init) &&
+            isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
+            for (const arg of init.arguments) {
+                forEachStringLiteralInClassExpression(arg, (lit) => {
+                    visitor(lit, sourceFile, init);
+                });
+            }
+        }
+    }
+}
+export function collectCnCallsInsideTv(sourceFile, obj, knownBindings, depth = 0) {
+    if (depth > MAX_OBJECT_DEPTH) {
+        return [];
+    }
+    const calls = [];
+    for (const prop of obj.properties) {
+        if (!isDomainPropertyAssignment(prop)) {
+            continue;
+        }
+        const init = prop.initializer;
+        if (isDomainArrayLiteralExpression(init)) {
+            for (const arrayElement of init.elements) {
+                if (isDomainSpreadElement(arrayElement)) {
+                    continue;
+                }
+                if (isDomainCallExpression(arrayElement) &&
+                    isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) {
+                    calls.push(arrayElement);
+                }
+                else if (isDomainObjectLiteralExpression(arrayElement)) {
+                    for (const objectProperty of arrayElement.properties) {
+                        if (!isDomainPropertyAssignment(objectProperty)) {
+                            continue;
+                        }
+                        const propName = propertyAssignmentNameText(objectProperty);
+                        if (propName !== "className" && propName !== "class") {
+                            continue;
+                        }
+                        const innerInit = objectProperty.initializer;
+                        if (isDomainCallExpression(innerInit) &&
+                            isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
+                            calls.push(innerInit);
+                        }
+                    }
+                }
+            }
+        }
+        else if (isDomainObjectLiteralExpression(init)) {
+            calls.push(...collectCnCallsInsideTv(sourceFile, init, knownBindings, depth + 1));
+        }
+        else if (isDomainCallExpression(init) &&
+            isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
+            calls.push(init);
+        }
+    }
+    return calls;
+}
+export function listAllCnCallsInsideTvInSourceFile(sourceFile, knownBindings) {
+    const calls = [];
+    const visitSubtree = (tsNode) => {
+        if (isDomainCallExpression(tsNode) &&
+            isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+            const arg0 = tsNode.arguments[0];
+            if (arg0 && isDomainObjectLiteralExpression(arg0)) {
+                calls.push(...collectCnCallsInsideTv(sourceFile, arg0, knownBindings, 0));
+            }
+        }
+        forEachDomainChild(tsNode, visitSubtree);
+    };
+    for (const stmt of sourceFile.statements) {
+        visitSubtree(stmt);
+    }
+    return calls;
+}
+export function makeStringNode(nodes, sourceFile, isTvContext, cnCall) {
+    return {
+        nodes,
+        sf: sourceFile,
+        isTvContext,
+        cnCall,
+        get primaryClassLiteral() {
+            return this.nodes[0];
+        },
+    };
+}
+export function slotClassString(stringNode) {
+    return stringNode.nodes.map((literal) => literal.text).join(" ");
+}
+export function emitTvSlot(lits, sourceFile, cnCall, results, seenNodePos) {
+    if (lits.length === 0) {
+        return;
+    }
+    const firstPos = lits[0].pos;
+    if (seenNodePos.has(firstPos)) {
+        return;
+    }
+    seenNodePos.add(firstPos);
+    const totalTokens = lits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0);
+    if (totalTokens < APPLY_MIN_TOKENS) {
+        return;
+    }
+    results.push(makeStringNode(lits, sourceFile, true, cnCall));
+}
+export function collectTvSlots(sourceFile, obj, knownBindings, results, seenNodePos, depth = 0) {
+    if (depth > MAX_OBJECT_DEPTH) {
+        return;
+    }
+    for (const prop of obj.properties) {
+        if (!isDomainPropertyAssignment(prop)) {
+            continue;
+        }
+        const init = prop.initializer;
+        if (isDomainTailwindClassLiteral(init)) {
+            emitTvSlot([init], sourceFile, undefined, results, seenNodePos);
+        }
+        else if (isDomainArrayLiteralExpression(init)) {
+            const arrayPos = init.pos;
+            if (seenNodePos.has(arrayPos)) {
+                continue;
+            }
+            seenNodePos.add(arrayPos);
+            const staticLits = [];
+            for (const arrayElement of init.elements) {
+                if (isDomainSpreadElement(arrayElement)) {
+                    continue;
+                }
+                if (isDomainTailwindClassLiteral(arrayElement)) {
+                    staticLits.push(arrayElement);
+                }
+                else if (isDomainCallExpression(arrayElement) &&
+                    isCnOrTvIdentifier(arrayElement.expression, "cn", knownBindings)) {
+                    for (const arg of arrayElement.arguments) {
+                        forEachStringLiteralInClassExpression(arg, (lit) => {
+                            if (!isUnsafeLiteralForCnStyleApplySplit(lit)) {
+                                staticLits.push(lit);
+                            }
+                        }, 0, CN_APPLY_LITERAL_WALK_OPTS);
+                    }
+                }
+                else if (isDomainObjectLiteralExpression(arrayElement)) {
+                    for (const objectProperty of arrayElement.properties) {
+                        if (!isDomainPropertyAssignment(objectProperty)) {
+                            continue;
+                        }
+                        const propName = propertyAssignmentNameText(objectProperty);
+                        if (propName !== "className" && propName !== "class") {
+                            continue;
+                        }
+                        const innerInit = objectProperty.initializer;
+                        if (isDomainTailwindClassLiteral(innerInit)) {
+                            emitTvSlot([innerInit], sourceFile, undefined, results, seenNodePos);
+                        }
+                        else if (isDomainArrayLiteralExpression(innerInit)) {
+                            const innerLits = [];
+                            for (const nestedArrayElement of innerInit.elements) {
+                                if (!isDomainSpreadElement(nestedArrayElement) &&
+                                    isDomainTailwindClassLiteral(nestedArrayElement)) {
+                                    innerLits.push(nestedArrayElement);
+                                }
+                            }
+                            emitTvSlot(innerLits, sourceFile, undefined, results, seenNodePos);
+                        }
+                        else if (isDomainCallExpression(innerInit) &&
+                            isCnOrTvIdentifier(innerInit.expression, "cn", knownBindings)) {
+                            const cnLits = [];
+                            for (const arg of innerInit.arguments) {
+                                forEachStringLiteralInClassExpression(arg, (lit) => {
+                                    if (!isUnsafeLiteralForCnStyleApplySplit(lit)) {
+                                        cnLits.push(lit);
+                                    }
+                                }, 0, CN_APPLY_LITERAL_WALK_OPTS);
+                            }
+                            emitTvSlot(cnLits, sourceFile, innerInit, results, seenNodePos);
+                        }
+                    }
+                }
+            }
+            if (staticLits.length > 0) {
+                emitTvSlot(staticLits, sourceFile, undefined, results, seenNodePos);
+            }
+        }
+        else if (isDomainObjectLiteralExpression(init)) {
+            collectTvSlots(sourceFile, init, knownBindings, results, seenNodePos, depth + 1);
+        }
+        else if (isDomainCallExpression(init) &&
+            isCnOrTvIdentifier(init.expression, "cn", knownBindings)) {
+            const cnLits = [];
+            for (const arg of init.arguments) {
+                forEachStringLiteralInClassExpression(arg, (lit) => {
+                    if (!isUnsafeLiteralForCnStyleApplySplit(lit)) {
+                        cnLits.push(lit);
+                    }
+                }, 0, CN_APPLY_LITERAL_WALK_OPTS);
+            }
+            emitTvSlot(cnLits, sourceFile, init, results, seenNodePos);
+        }
+    }
+}
+export function collectGroupableStringNodes(sourceFile) {
+    const results = [];
+    const seenNodePos = new Set();
+    const knownBindings = buildKnownCnTvBindings(sourceFile);
+    const visitTypeScriptSubtree = (tsNode) => {
+        if (isDomainCallExpression(tsNode)) {
+            if (isCnOrTvIdentifier(tsNode.expression, "cn", knownBindings)) {
+                const callPos = tsNode.pos;
+                if (seenNodePos.has(callPos)) {
+                    forEachDomainChild(tsNode, visitTypeScriptSubtree);
+                    return;
+                }
+                seenNodePos.add(callPos);
+                const staticLits = collectUnconditionalTailwindLiteralsFromCnArguments(tsNode.arguments);
+                const totalTokens = staticLits.reduce((accumulatedTokenCount, literal) => accumulatedTokenCount + tokenizeClassString(literal.text).length, 0);
+                if (staticLits.length > 0 && totalTokens >= APPLY_MIN_TOKENS) {
+                    results.push(makeStringNode(staticLits, sourceFile, false, tsNode));
+                }
+            }
+            else if (isCnOrTvIdentifier(tsNode.expression, "tv", knownBindings)) {
+                const arg0 = tsNode.arguments[0];
+                if (arg0 && isDomainObjectLiteralExpression(arg0)) {
+                    collectTvSlots(sourceFile, arg0, knownBindings, results, seenNodePos);
+                }
+            }
+        }
+        forEachDomainChild(tsNode, visitTypeScriptSubtree);
+    };
+    for (const stmt of sourceFile.statements) {
+        visitTypeScriptSubtree(stmt);
+    }
+    return results;
+}

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

@@ -0,0 +1,8 @@
+import type { GroupTarget, PlannedGroupEdit, StringNode } from "#lib/arrange/domain/types";
+import { type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+export declare function targetReplaceStart(target: GroupTarget): number;
+export declare function collectLongJsxClassNameTargets(sourceFile: DomainSourceFile): GroupTarget[];
+export declare function collectGroupTargets(sourceFile: DomainSourceFile, filePath: string): GroupTarget[];
+export declare function formatCnCallReplacement(stringNode: 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/domain/ast/targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/targets.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAS3F,OAAO,EAEL,KAAK,gBAAgB,EAKtB,MAAM,wCAAwC,CAAC;AAEhD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAK9D;AAED,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,gBAAgB,GAAG,WAAW,EAAE,CAoB1F;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE,CASjG;AAED,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,OAAO,GACrB,MAAM,CAyCR;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,WAAW,EACnB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,OAAO,GACrB,gBAAgB,GAAG,SAAS,CA6E9B"}

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

@@ -0,0 +1,147 @@
+import { APPLY_MIN_TOKENS } from "#lib/arrange/domain/constants";
+import { areCnTailwindPartitionsEquivalent, suggestCnGroups, summarizeGroupBucketLabels, } from "#lib/arrange/domain/grouping";
+import { escapeTsStringLiteralContent, formatArray, formatJsxCnAttributeValue, } from "#lib/arrange/domain/source-text-formatters";
+import { tokenizeClassString } from "#lib/arrange/domain/tokenizer";
+import { isUnsafeLiteralForCnStyleApplySplit } from "#lib/arrange/domain/ast/collectors-cn";
+import { jsxClassNameStaticLiteral } from "#lib/arrange/domain/ast/collectors-jsx";
+import { collectGroupableStringNodes, slotClassString, } from "#lib/arrange/domain/ast/collectors-tv";
+import { indentOfLineContaining } from "#lib/shared/source-code/domain/text-edit";
+import { isDomainArrayLiteralExpression, isDomainJsxAttribute, isDomainTailwindClassLiteral, forEachDomainChild, } from "#lib/arrange/domain/ast/ast-node.model";
+export function targetReplaceStart(target) {
+    if (target.kind === "cnArg") {
+        return target.item.cnCall ? target.item.cnCall.pos : target.item.primaryClassLiteral.pos;
+    }
+    return target.valueNode.pos;
+}
+export function collectLongJsxClassNameTargets(sourceFile) {
+    const results = [];
+    const visitTypeScriptSubtree = (tsNode) => {
+        if (isDomainJsxAttribute(tsNode)) {
+            const parsed = jsxClassNameStaticLiteral(tsNode);
+            if (parsed && tokenizeClassString(parsed.lit.text).length >= APPLY_MIN_TOKENS) {
+                results.push({
+                    kind: "jsxClassName",
+                    sf: sourceFile,
+                    lit: parsed.lit,
+                    valueNode: parsed.valueNode,
+                });
+            }
+        }
+        forEachDomainChild(tsNode, visitTypeScriptSubtree);
+    };
+    for (const stmt of sourceFile.statements) {
+        visitTypeScriptSubtree(stmt);
+    }
+    return results;
+}
+export function collectGroupTargets(sourceFile, filePath) {
+    const cnPart = collectGroupableStringNodes(sourceFile).map((stringNode) => ({
+        kind: "cnArg",
+        item: stringNode,
+    }));
+    if (!filePath.endsWith(".tsx")) {
+        return cnPart;
+    }
+    return [...cnPart, ...collectLongJsxClassNameTargets(sourceFile)];
+}
+export function formatCnCallReplacement(stringNode, sourceText, withClassName) {
+    const call = stringNode.cnCall;
+    const baseIndent = indentOfLineContaining(sourceText, call.pos);
+    const argIndent = `${baseIndent}  `;
+    const dynamicArgTexts = [];
+    for (const arg of call.arguments) {
+        const isSimpleStatic = isDomainTailwindClassLiteral(arg) && !isUnsafeLiteralForCnStyleApplySplit(arg);
+        if (!isSimpleStatic) {
+            dynamicArgTexts.push(sourceText.slice(arg.pos, arg.end));
+        }
+    }
+    const pool = slotClassString(stringNode);
+    const groups = pool.trim() ? suggestCnGroups(pool) : [];
+    const allArgs = [];
+    if (groups.length > 1) {
+        for (const group of groups) {
+            allArgs.push(`${argIndent}"${escapeTsStringLiteralContent(group)}"`);
+        }
+    }
+    else if (groups.length === 1) {
+        allArgs.push(`${argIndent}"${escapeTsStringLiteralContent(groups[0])}"`);
+    }
+    for (const dynamicArgumentSource of dynamicArgTexts) {
+        allArgs.push(`${argIndent}${dynamicArgumentSource}`);
+    }
+    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.pos;
+        const end = target.valueNode.end;
+        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((classLiteral) => classLiteral.text), groups)) {
+        return undefined;
+    }
+    if (!target.item.cnCall) {
+        const anchorClassLiteral = target.item.primaryClassLiteral;
+        const parentArray = target.item.nodes.length > 1 &&
+            anchorClassLiteral.parent !== null &&
+            isDomainArrayLiteralExpression(anchorClassLiteral.parent)
+            ? anchorClassLiteral.parent
+            : null;
+        const start = parentArray ? parentArray.pos : anchorClassLiteral.pos;
+        const end = parentArray ? parentArray.end : anchorClassLiteral.end;
+        const baseIndent = indentOfLineContaining(textAfterUnwrap, start);
+        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: anchorClassLiteral,
+            label: target.item.isTvContext ? "tv" : "cn",
+        };
+    }
+    const call = target.item.cnCall;
+    const start = call.pos;
+    const end = call.end;
+    const replacement = formatCnCallReplacement(target.item, textAfterUnwrap, withClassName);
+    return {
+        start,
+        end,
+        replacement,
+        bucketSummary: summarizeGroupBucketLabels(groups),
+        jsxCn: false,
+        lineSf: target.item.sf,
+        reportNode: target.item.primaryClassLiteral,
+        label: target.item.isTvContext ? "tv" : "cn",
+    };
+}

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

@@ -0,0 +1,68 @@
+import type { Bucket } from "#lib/arrange/domain/types";
+/** Analyze report: long literal threshold (token count). */
+export declare const LONG_STRING_TOKEN_THRESHOLD = 18;
+/**
+ * Minimum token count for a string to be considered a candidate for grouping
+ * in the apply/preview pipeline. Intentionally much lower than
+ * {@link LONG_STRING_TOKEN_THRESHOLD} (analyze only).
+ */
+export declare const APPLY_MIN_TOKENS = 2;
+/**
+ * Minimum tokens a group must have to stand alone before singleton-merging.
+ * Set to 2 so single-token groups are not collapsed into unrelated buckets by the merger.
+ */
+export declare const MIN_GROUP_TOKENS = 2;
+/** Dynamic max groups clamp: base bound. */
+export declare const MAX_GROUPS_BASE = 4;
+/** Dynamic max groups clamp: upper cap. */
+export declare const MAX_GROUPS_CAP = 24;
+/**
+ * Extra slots so a few state / aria groups do not force `capGroups` to merge
+ * unrelated buckets (e.g. `bg-border` + `outline-hidden`).
+ */
+export declare const MAX_GROUPS_HEADROOM = 2;
+/** Maximum findings printed per category in the analyze report. */
+export declare const MAX_REPORT_LINES = 40;
+/** Maximum recursion depth when traversing `tv()` object literals. */
+export declare const MAX_OBJECT_DEPTH = 12;
+/** Maximum depth when peeling conditional / parens / arrays inside `cn(...)` args. */
+export declare const MAX_CLASS_EXPR_DEPTH = 12;
+/**
+ * Maximum variant-stripping passes in {@link stripVariants}.
+ * Real-world Tailwind stacks rarely exceed 4–5 segments (e.g. `@md/sidebar:group-hover:dark:focus-visible:`);
+ * 12 is a conservative safety cap that prevents runaway loops on malformed input.
+ */
+export declare const MAX_STRIP_VARIANT_PASSES = 12;
+/**
+ * Passed when optional `knownBindings` is missing — size 0 disables matching
+ * for `cn` / `tv` identifier resolution.
+ */
+export declare const EMPTY_CN_TV_BINDINGS: Set<string>;
+/**
+ * Bucket sort order — **render pipeline** (lower → earlier in output).
+ * Existence → Position → Layout → Sizing → Spacing → Shape → Background → Shadow
+ * → Typography → Composite → Motion → Starting → Behavior → State (variants) → Selector variants.
+ */
+export declare const BUCKET_ORDER: Record<Bucket, number>;
+/**
+ * Compatible bucket **pairs** — two adjacent tokens whose buckets appear in the same
+ * `Set` may stay in one `cn()` string chunk. Compatibility is **not transitive**: there is
+ * no `{position, sizing}` pair, so `fixed inset-0` and `overflow-auto` become **separate**
+ * literals unless **layout** tokens sit between them in sorted order; then
+ * `position↔layout` and `layout↔sizing` each justify one hop and the whole “box in flow”
+ * (place + tracks + scrollport) stays in one chunk — co-located because they jointly define
+ * stacking and scroll behavior for the same surface.
+ */
+export declare const COMPATIBLE_BUCKET_SETS: ReadonlyArray<ReadonlySet<Bucket>>;
+/**
+ * Responsive / variant prefix — Tailwind v4 aware.
+ *
+ * v3: sm: md: … — v4: @sm:, @min-[600px]:, @[480px]:, named @md/sidebar:,
+ * viewport md/sidebar:, min-[100px]: / max-[100px]:, …
+ */
+export declare const RESPONSIVE_PREFIX: RegExp;
+/** State variant stems — hoisted to module scope (not recreated per call). */
+export declare const STATE_PREFIXES: Set<string>;
+/** Default directory for arrange analyze/preview/apply when no target is passed. */
+export declare const DEFAULT_ARRANGE_TARGET = "packages/ui/src/components";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAExD,4DAA4D;AAC5D,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,4CAA4C;AAC5C,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,2CAA2C;AAC3C,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;GAGG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,oBAAoB,aAAoB,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkB/C,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,WAAW,CAAC,MAAM,CAAC,CA6BrE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,QAC2J,CAAC;AAE1L,8EAA8E;AAC9E,eAAO,MAAM,cAAc,aAmEzB,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,sBAAsB,+BAA+B,CAAC"}