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

package/dist/lib/arrange/domain/ast/ast-node.model.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Pure-domain AST shapes for arrange analysis. No TypeScript compiler types.
+ * Positions mirror `getStart(sourceFile)` / `getEnd()` semantics from translation.
+ */
+export declare enum DomainSyntaxKind {
+    Unknown = 1,
+    Identifier = 2,
+    StringLiteral = 3,
+    NoSubstitutionTemplateLiteral = 4,
+    ImportDeclaration = 5,
+    ImportClause = 6,
+    NamedImports = 7,
+    NamespaceImport = 8,
+    ImportSpecifier = 9,
+    CallExpression = 10,
+    PropertyAccessExpression = 11,
+    ObjectLiteralExpression = 12,
+    PropertyAssignment = 13,
+    ArrayLiteralExpression = 14,
+    SpreadElement = 15,
+    ParenthesizedExpression = 16,
+    AsExpression = 17,
+    SatisfiesExpression = 18,
+    NonNullExpression = 19,
+    ConditionalExpression = 20,
+    BinaryExpression = 21,
+    ExpressionStatement = 22,
+    JsxAttribute = 23,
+    JsxExpression = 24
+}
+export declare enum DomainBinaryOperator {
+    Plus = 0,
+    Other = 1
+}
+export interface DomainSourceFile {
+    readonly fileName: string;
+    readonly text: string;
+    readonly statements: readonly DomainAstNode[];
+}
+interface DomainNodeBase {
+    readonly kind: DomainSyntaxKind;
+    readonly pos: number;
+    readonly end: number;
+    readonly parent: DomainAstNode | null;
+}
+export interface DomainUnknownAstNode extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.Unknown;
+    readonly children: readonly DomainAstNode[];
+}
+export interface DomainIdentifier extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.Identifier;
+    readonly text: string;
+}
+export interface DomainStringLiteral extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.StringLiteral;
+    readonly text: string;
+}
+export interface DomainNoSubstitutionTemplateLiteral extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.NoSubstitutionTemplateLiteral;
+    readonly text: string;
+}
+export interface DomainImportDeclaration extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ImportDeclaration;
+    readonly importClause: DomainImportClause | undefined;
+    readonly moduleSpecifier: DomainAstNode;
+}
+export interface DomainImportClause extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ImportClause;
+    readonly isTypeOnly: boolean;
+    readonly name: DomainIdentifier | undefined;
+    readonly namedBindings: DomainNamedImports | DomainNamespaceImport | undefined;
+}
+export interface DomainNamedImports extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.NamedImports;
+    readonly elements: readonly DomainImportSpecifier[];
+}
+export interface DomainNamespaceImport extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.NamespaceImport;
+    readonly name: DomainIdentifier;
+}
+export interface DomainImportSpecifier extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ImportSpecifier;
+    readonly name: DomainIdentifier;
+    readonly propertyName: DomainIdentifier | undefined;
+}
+export interface DomainCallExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.CallExpression;
+    readonly expression: DomainAstNode;
+    readonly arguments: readonly DomainAstNode[];
+}
+export interface DomainPropertyAccessExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.PropertyAccessExpression;
+    readonly expression: DomainAstNode;
+    readonly name: DomainIdentifier;
+}
+export interface DomainObjectLiteralExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ObjectLiteralExpression;
+    readonly properties: readonly DomainAstNode[];
+}
+export interface DomainPropertyAssignment extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.PropertyAssignment;
+    readonly name: DomainAstNode;
+    readonly initializer: DomainAstNode;
+}
+export interface DomainArrayLiteralExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ArrayLiteralExpression;
+    readonly elements: readonly DomainAstNode[];
+}
+export interface DomainSpreadElement extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.SpreadElement;
+    readonly expression: DomainAstNode;
+}
+export interface DomainParenthesizedExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ParenthesizedExpression;
+    readonly expression: DomainAstNode;
+}
+export interface DomainAsExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.AsExpression;
+    readonly expression: DomainAstNode;
+}
+export interface DomainSatisfiesExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.SatisfiesExpression;
+    readonly expression: DomainAstNode;
+}
+export interface DomainNonNullExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.NonNullExpression;
+    readonly expression: DomainAstNode;
+}
+export interface DomainConditionalExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ConditionalExpression;
+    readonly condition: DomainAstNode;
+    readonly whenTrue: DomainAstNode;
+    readonly whenFalse: DomainAstNode;
+}
+export interface DomainBinaryExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.BinaryExpression;
+    readonly left: DomainAstNode;
+    readonly operator: DomainBinaryOperator;
+    readonly right: DomainAstNode;
+}
+export interface DomainExpressionStatement extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ExpressionStatement;
+    readonly expression: DomainAstNode;
+}
+export interface DomainJsxAttribute extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.JsxAttribute;
+    readonly name: DomainAstNode;
+    readonly initializer: DomainAstNode | undefined;
+}
+export interface DomainJsxExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.JsxExpression;
+    readonly expression: DomainAstNode | undefined;
+}
+export type DomainAstNode = DomainUnknownAstNode | DomainIdentifier | DomainStringLiteral | DomainNoSubstitutionTemplateLiteral | DomainImportDeclaration | DomainImportClause | DomainNamedImports | DomainNamespaceImport | DomainImportSpecifier | DomainCallExpression | DomainPropertyAccessExpression | DomainObjectLiteralExpression | DomainPropertyAssignment | DomainArrayLiteralExpression | DomainSpreadElement | DomainParenthesizedExpression | DomainAsExpression | DomainSatisfiesExpression | DomainNonNullExpression | DomainConditionalExpression | DomainBinaryExpression | DomainExpressionStatement | DomainJsxAttribute | DomainJsxExpression;
+export type DomainTailwindClassLiteral = DomainStringLiteral | DomainNoSubstitutionTemplateLiteral;
+export declare function isDomainIdentifier(node: DomainAstNode): node is DomainIdentifier;
+export declare function isDomainStringLiteral(node: DomainAstNode): node is DomainStringLiteral;
+export declare function isDomainNoSubstitutionTemplateLiteral(node: DomainAstNode): node is DomainNoSubstitutionTemplateLiteral;
+export declare function isDomainTailwindClassLiteral(node: DomainAstNode): node is DomainTailwindClassLiteral;
+export declare function isDomainImportDeclaration(node: DomainAstNode): node is DomainImportDeclaration;
+export declare function isDomainImportClause(node: DomainAstNode | undefined): node is DomainImportClause;
+export declare function isDomainNamedImports(node: DomainAstNode): node is DomainNamedImports;
+export declare function isDomainNamespaceImport(node: DomainAstNode): node is DomainNamespaceImport;
+export declare function isDomainCallExpression(node: DomainAstNode): node is DomainCallExpression;
+export declare function isDomainObjectLiteralExpression(node: DomainAstNode): node is DomainObjectLiteralExpression;
+export declare function isDomainPropertyAssignment(node: DomainAstNode): node is DomainPropertyAssignment;
+export declare function isDomainArrayLiteralExpression(node: DomainAstNode): node is DomainArrayLiteralExpression;
+export declare function isDomainSpreadElement(node: DomainAstNode): node is DomainSpreadElement;
+export declare function isDomainPropertyAccessExpression(node: DomainAstNode): node is DomainPropertyAccessExpression;
+export declare function isDomainJsxAttribute(node: DomainAstNode): node is DomainJsxAttribute;
+export declare function isDomainJsxExpression(node: DomainAstNode): node is DomainJsxExpression;
+export declare function isDomainExpressionStatement(node: DomainAstNode): node is DomainExpressionStatement;
+export declare function forEachDomainChild(node: DomainAstNode, visit: (child: DomainAstNode) => void): void;
+export declare function forEachDomainDescendant(node: DomainAstNode, visit: (n: DomainAstNode) => void): void;
+export declare function forEachDomainDescendantFromSourceFile(sourceFile: DomainSourceFile, visit: (n: DomainAstNode) => void): void;
+export declare function findFirstDomainDescendantWhere(sourceFile: DomainSourceFile, predicate: (n: DomainAstNode) => boolean): DomainAstNode | undefined;
+export declare function lineOfSourcePosition(sourceText: string, pos: number): number;
+export {};
+//# sourceMappingURL=ast-node.model.d.ts.map

package/dist/lib/arrange/domain/ast/ast-node.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-node.model.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/ast-node.model.ts"],"names":[],"mappings":"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"}

package/dist/lib/arrange/domain/ast/ast-node.model.js

@@ -0,0 +1,210 @@
+/**
+ * Pure-domain AST shapes for arrange analysis. No TypeScript compiler types.
+ * Positions mirror `getStart(sourceFile)` / `getEnd()` semantics from translation.
+ */
+export var DomainSyntaxKind;
+(function (DomainSyntaxKind) {
+    DomainSyntaxKind[DomainSyntaxKind["Unknown"] = 1] = "Unknown";
+    DomainSyntaxKind[DomainSyntaxKind["Identifier"] = 2] = "Identifier";
+    DomainSyntaxKind[DomainSyntaxKind["StringLiteral"] = 3] = "StringLiteral";
+    DomainSyntaxKind[DomainSyntaxKind["NoSubstitutionTemplateLiteral"] = 4] = "NoSubstitutionTemplateLiteral";
+    DomainSyntaxKind[DomainSyntaxKind["ImportDeclaration"] = 5] = "ImportDeclaration";
+    DomainSyntaxKind[DomainSyntaxKind["ImportClause"] = 6] = "ImportClause";
+    DomainSyntaxKind[DomainSyntaxKind["NamedImports"] = 7] = "NamedImports";
+    DomainSyntaxKind[DomainSyntaxKind["NamespaceImport"] = 8] = "NamespaceImport";
+    DomainSyntaxKind[DomainSyntaxKind["ImportSpecifier"] = 9] = "ImportSpecifier";
+    DomainSyntaxKind[DomainSyntaxKind["CallExpression"] = 10] = "CallExpression";
+    DomainSyntaxKind[DomainSyntaxKind["PropertyAccessExpression"] = 11] = "PropertyAccessExpression";
+    DomainSyntaxKind[DomainSyntaxKind["ObjectLiteralExpression"] = 12] = "ObjectLiteralExpression";
+    DomainSyntaxKind[DomainSyntaxKind["PropertyAssignment"] = 13] = "PropertyAssignment";
+    DomainSyntaxKind[DomainSyntaxKind["ArrayLiteralExpression"] = 14] = "ArrayLiteralExpression";
+    DomainSyntaxKind[DomainSyntaxKind["SpreadElement"] = 15] = "SpreadElement";
+    DomainSyntaxKind[DomainSyntaxKind["ParenthesizedExpression"] = 16] = "ParenthesizedExpression";
+    DomainSyntaxKind[DomainSyntaxKind["AsExpression"] = 17] = "AsExpression";
+    DomainSyntaxKind[DomainSyntaxKind["SatisfiesExpression"] = 18] = "SatisfiesExpression";
+    DomainSyntaxKind[DomainSyntaxKind["NonNullExpression"] = 19] = "NonNullExpression";
+    DomainSyntaxKind[DomainSyntaxKind["ConditionalExpression"] = 20] = "ConditionalExpression";
+    DomainSyntaxKind[DomainSyntaxKind["BinaryExpression"] = 21] = "BinaryExpression";
+    DomainSyntaxKind[DomainSyntaxKind["ExpressionStatement"] = 22] = "ExpressionStatement";
+    DomainSyntaxKind[DomainSyntaxKind["JsxAttribute"] = 23] = "JsxAttribute";
+    DomainSyntaxKind[DomainSyntaxKind["JsxExpression"] = 24] = "JsxExpression";
+})(DomainSyntaxKind || (DomainSyntaxKind = {}));
+export var DomainBinaryOperator;
+(function (DomainBinaryOperator) {
+    DomainBinaryOperator[DomainBinaryOperator["Plus"] = 0] = "Plus";
+    DomainBinaryOperator[DomainBinaryOperator["Other"] = 1] = "Other";
+})(DomainBinaryOperator || (DomainBinaryOperator = {}));
+export function isDomainIdentifier(node) {
+    return node.kind === DomainSyntaxKind.Identifier;
+}
+export function isDomainStringLiteral(node) {
+    return node.kind === DomainSyntaxKind.StringLiteral;
+}
+export function isDomainNoSubstitutionTemplateLiteral(node) {
+    return node.kind === DomainSyntaxKind.NoSubstitutionTemplateLiteral;
+}
+export function isDomainTailwindClassLiteral(node) {
+    return isDomainStringLiteral(node) || isDomainNoSubstitutionTemplateLiteral(node);
+}
+export function isDomainImportDeclaration(node) {
+    return node.kind === DomainSyntaxKind.ImportDeclaration;
+}
+export function isDomainImportClause(node) {
+    return node !== undefined && node.kind === DomainSyntaxKind.ImportClause;
+}
+export function isDomainNamedImports(node) {
+    return node.kind === DomainSyntaxKind.NamedImports;
+}
+export function isDomainNamespaceImport(node) {
+    return node.kind === DomainSyntaxKind.NamespaceImport;
+}
+export function isDomainCallExpression(node) {
+    return node.kind === DomainSyntaxKind.CallExpression;
+}
+export function isDomainObjectLiteralExpression(node) {
+    return node.kind === DomainSyntaxKind.ObjectLiteralExpression;
+}
+export function isDomainPropertyAssignment(node) {
+    return node.kind === DomainSyntaxKind.PropertyAssignment;
+}
+export function isDomainArrayLiteralExpression(node) {
+    return node.kind === DomainSyntaxKind.ArrayLiteralExpression;
+}
+export function isDomainSpreadElement(node) {
+    return node.kind === DomainSyntaxKind.SpreadElement;
+}
+export function isDomainPropertyAccessExpression(node) {
+    return node.kind === DomainSyntaxKind.PropertyAccessExpression;
+}
+export function isDomainJsxAttribute(node) {
+    return node.kind === DomainSyntaxKind.JsxAttribute;
+}
+export function isDomainJsxExpression(node) {
+    return node.kind === DomainSyntaxKind.JsxExpression;
+}
+export function isDomainExpressionStatement(node) {
+    return node.kind === DomainSyntaxKind.ExpressionStatement;
+}
+export function forEachDomainChild(node, visit) {
+    switch (node.kind) {
+        case DomainSyntaxKind.Unknown:
+            for (const child of node.children) {
+                visit(child);
+            }
+            return;
+        case DomainSyntaxKind.ImportDeclaration:
+            if (node.importClause) {
+                visit(node.importClause);
+            }
+            visit(node.moduleSpecifier);
+            return;
+        case DomainSyntaxKind.ImportClause:
+            if (node.name) {
+                visit(node.name);
+            }
+            if (node.namedBindings) {
+                visit(node.namedBindings);
+            }
+            return;
+        case DomainSyntaxKind.NamedImports:
+            for (const element of node.elements) {
+                visit(element);
+            }
+            return;
+        case DomainSyntaxKind.NamespaceImport:
+            visit(node.name);
+            return;
+        case DomainSyntaxKind.ImportSpecifier:
+            if (node.propertyName) {
+                visit(node.propertyName);
+            }
+            visit(node.name);
+            return;
+        case DomainSyntaxKind.CallExpression:
+            visit(node.expression);
+            for (const arg of node.arguments) {
+                visit(arg);
+            }
+            return;
+        case DomainSyntaxKind.PropertyAccessExpression:
+            visit(node.expression);
+            visit(node.name);
+            return;
+        case DomainSyntaxKind.ObjectLiteralExpression:
+            for (const prop of node.properties) {
+                visit(prop);
+            }
+            return;
+        case DomainSyntaxKind.PropertyAssignment:
+            visit(node.name);
+            visit(node.initializer);
+            return;
+        case DomainSyntaxKind.ArrayLiteralExpression:
+            for (const element of node.elements) {
+                visit(element);
+            }
+            return;
+        case DomainSyntaxKind.SpreadElement:
+            visit(node.expression);
+            return;
+        case DomainSyntaxKind.ParenthesizedExpression:
+        case DomainSyntaxKind.AsExpression:
+        case DomainSyntaxKind.SatisfiesExpression:
+        case DomainSyntaxKind.NonNullExpression:
+            visit(node.expression);
+            return;
+        case DomainSyntaxKind.ConditionalExpression:
+            visit(node.condition);
+            visit(node.whenTrue);
+            visit(node.whenFalse);
+            return;
+        case DomainSyntaxKind.BinaryExpression:
+            visit(node.left);
+            visit(node.right);
+            return;
+        case DomainSyntaxKind.ExpressionStatement:
+            visit(node.expression);
+            return;
+        case DomainSyntaxKind.JsxAttribute:
+            visit(node.name);
+            if (node.initializer) {
+                visit(node.initializer);
+            }
+            return;
+        case DomainSyntaxKind.JsxExpression:
+            if (node.expression) {
+                visit(node.expression);
+            }
+            return;
+        default:
+            return;
+    }
+}
+export function forEachDomainDescendant(node, visit) {
+    visit(node);
+    forEachDomainChild(node, (child) => forEachDomainDescendant(child, visit));
+}
+export function forEachDomainDescendantFromSourceFile(sourceFile, visit) {
+    for (const statement of sourceFile.statements) {
+        forEachDomainDescendant(statement, visit);
+    }
+}
+export function findFirstDomainDescendantWhere(sourceFile, predicate) {
+    let found;
+    forEachDomainDescendantFromSourceFile(sourceFile, (n) => {
+        if (found === undefined && predicate(n)) {
+            found = n;
+        }
+    });
+    return found;
+}
+export function lineOfSourcePosition(sourceText, pos) {
+    const boundedPos = Math.max(0, Math.min(pos, sourceText.length));
+    let line = 1;
+    for (let i = 0; i < boundedPos; i++) {
+        if (sourceText.charCodeAt(i) === 10) {
+            line++;
+        }
+    }
+    return line;
+}

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

@@ -0,0 +1,7 @@
+import type { ForEachStringLiteralInClassExpressionOptions, TailwindClassLiteral } from "#lib/arrange/domain/types";
+import { type DomainAstNode } from "#lib/arrange/domain/ast/ast-node.model";
+export declare function forEachStringLiteralInClassExpression(expr: DomainAstNode, sink: (classLiteral: TailwindClassLiteral) => void, depth?: number, options?: ForEachStringLiteralInClassExpressionOptions): void;
+export declare function isUnsafeLiteralForCnStyleApplySplit(classLiteral: TailwindClassLiteral): boolean;
+export declare const CN_APPLY_LITERAL_WALK_OPTS: ForEachStringLiteralInClassExpressionOptions;
+export declare function collectUnconditionalTailwindLiteralsFromCnArguments(args: readonly DomainAstNode[]): TailwindClassLiteral[];
+//# sourceMappingURL=collectors-cn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectors-cn.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/collectors-cn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,4CAA4C,EAC5C,oBAAoB,EACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAGL,KAAK,aAAa,EAGnB,MAAM,wCAAwC,CAAC;AAEhD,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,CAAC,YAAY,EAAE,oBAAoB,KAAK,IAAI,EAClD,KAAK,SAAI,EACT,OAAO,CAAC,EAAE,4CAA4C,GACrD,IAAI,CAsDN;AAED,wBAAgB,mCAAmC,CAAC,YAAY,EAAE,oBAAoB,GAAG,OAAO,CAE/F;AAED,eAAO,MAAM,0BAA0B,EAAE,4CAExC,CAAC;AAEF,wBAAgB,mDAAmD,CACjE,IAAI,EAAE,SAAS,aAAa,EAAE,GAC7B,oBAAoB,EAAE,CAqBxB"}

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

@@ -0,0 +1,70 @@
+import { MAX_CLASS_EXPR_DEPTH } from "#lib/arrange/domain/constants";
+import { DomainBinaryOperator, DomainSyntaxKind, isDomainArrayLiteralExpression, isDomainTailwindClassLiteral, } from "#lib/arrange/domain/ast/ast-node.model";
+export function forEachStringLiteralInClassExpression(expr, sink, depth = 0, options) {
+    if (depth > MAX_CLASS_EXPR_DEPTH) {
+        return;
+    }
+    if (isDomainTailwindClassLiteral(expr)) {
+        sink(expr);
+        return;
+    }
+    if (expr.kind === DomainSyntaxKind.ParenthesizedExpression) {
+        forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+        return;
+    }
+    if (expr.kind === DomainSyntaxKind.AsExpression ||
+        expr.kind === DomainSyntaxKind.SatisfiesExpression) {
+        forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+        return;
+    }
+    if (expr.kind === DomainSyntaxKind.NonNullExpression) {
+        forEachStringLiteralInClassExpression(expr.expression, sink, depth + 1, options);
+        return;
+    }
+    if (expr.kind === DomainSyntaxKind.ConditionalExpression) {
+        if (options?.descendIntoConditional === false) {
+            return;
+        }
+        forEachStringLiteralInClassExpression(expr.whenTrue, sink, depth + 1, options);
+        forEachStringLiteralInClassExpression(expr.whenFalse, sink, depth + 1, options);
+        return;
+    }
+    if (expr.kind === DomainSyntaxKind.BinaryExpression &&
+        expr.operator === DomainBinaryOperator.Plus) {
+        forEachStringLiteralInClassExpression(expr.left, sink, depth + 1, options);
+        forEachStringLiteralInClassExpression(expr.right, sink, depth + 1, options);
+        return;
+    }
+    if (isDomainArrayLiteralExpression(expr)) {
+        for (const arrayElement of expr.elements) {
+            if (arrayElement.kind === DomainSyntaxKind.SpreadElement) {
+                continue;
+            }
+            forEachStringLiteralInClassExpression(arrayElement, sink, depth + 1, options);
+        }
+    }
+}
+export function isUnsafeLiteralForCnStyleApplySplit(classLiteral) {
+    return classLiteral.parent !== null && isDomainArrayLiteralExpression(classLiteral.parent);
+}
+export const CN_APPLY_LITERAL_WALK_OPTS = {
+    descendIntoConditional: false,
+};
+export function collectUnconditionalTailwindLiteralsFromCnArguments(args) {
+    const staticLits = [];
+    for (const arg of args) {
+        if (isDomainTailwindClassLiteral(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;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectors-jsx.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/collectors-jsx.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,wBAAgB,yBAAyB,CACvC,qBAAqB,EAAE,kBAAkB,GACxC,kBAAkB,GAAG,SAAS,CAsBhC"}

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

@@ -0,0 +1,21 @@
+import { isDomainIdentifier, isDomainJsxExpression, isDomainTailwindClassLiteral, } from "#lib/arrange/domain/ast/ast-node.model";
+export function jsxClassNameStaticLiteral(jsxClassNameAttribute) {
+    if (!isDomainIdentifier(jsxClassNameAttribute.name) ||
+        jsxClassNameAttribute.name.text !== "className") {
+        return undefined;
+    }
+    const init = jsxClassNameAttribute.initializer;
+    if (!init) {
+        return undefined;
+    }
+    if (isDomainTailwindClassLiteral(init)) {
+        return { lit: init, valueNode: init };
+    }
+    if (isDomainJsxExpression(init) && init.expression) {
+        const jsxExpressionBody = init.expression;
+        if (isDomainTailwindClassLiteral(jsxExpressionBody)) {
+            return { lit: jsxExpressionBody, valueNode: init };
+        }
+    }
+    return undefined;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectors-tv.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/collectors-tv.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,6BAA6B,EAClC,KAAK,gBAAgB,EAQtB,MAAM,wCAAwC,CAAC;AAOhD,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAQlF,KAAK,iBAAiB,GAAG,CACvB,YAAY,EAAE,oBAAoB,EAClC,UAAU,EAAE,gBAAgB,EAC5B,MAAM,CAAC,EAAE,oBAAoB,KAC1B,IAAI,CAAC;AAEV,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,6BAA6B,EAClC,OAAO,EAAE,iBAAiB,EAC1B,KAAK,SAAI,EACT,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC1B,IAAI,CA2EN;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,6BAA6B,EAClC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,KAAK,SAAI,GACR,oBAAoB,EAAE,CAkDxB;AAED,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,gBAAgB,EAC5B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,oBAAoB,EAAE,CAkBxB;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,oBAAoB,EAAE,EAC7B,UAAU,EAAE,gBAAgB,EAC5B,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,oBAAoB,GAC5B,UAAU,CAUZ;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAE9D;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,oBAAoB,EAAE,EAC5B,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,oBAAoB,GAAG,SAAS,EACxC,OAAO,EAAE,UAAU,EAAE,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GACvB,IAAI,CAmBN;AAED,wBAAgB,cAAc,CAC5B,UAAU,EAAE,gBAAgB,EAC5B,GAAG,EAAE,6BAA6B,EAClC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,OAAO,EAAE,UAAU,EAAE,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,KAAK,SAAI,GACR,IAAI,CAiHN;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,gBAAgB,GAAG,UAAU,EAAE,CAuCtF"}