@codefast/cli 0.9.0 → 0.11.0

package/dist/arrange/command.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+/**
+ * Creates the `arrange` command and its subcommands.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function createArrangeCommand(): Command;

package/dist/arrange/command.js

@@ -1,18 +1,96 @@
-import process from "node:process";
 import { Command } from "commander";
-import { analyzeDirectory } from "#/arrange/analyze";
-import { arrangeAnalyzeDirectoryRequestSchema, arrangeSuggestGroupsRequestSchema, arrangeSyncRunRequestSchema, } from "#/arrange/cli-schema";
-import { printAnalyzeReport, printGroupFilePreviewFromWork, printSimplifyResult, printSyncResult, } from "#/arrange/output";
-import { runArrangeSimplify } from "#/arrange/simplify-sync";
-import { suggestCnGroupsFromCli } from "#/arrange/suggest";
-import { runArrangeSync } from "#/arrange/sync";
-import { prepareArrangeWorkspace } from "#/arrange/workspace";
-import { readOptionalPositionalArg } from "#/core/cli/positional";
-import { consumeCliAppError, runCliResultAsync } from "#/core/cli/result-handle";
-import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
+import { formatArrangeGroupJsonOutput } from "#/arrange/group/cli-result";
+import { arrangeSuggestGroupsRequestSchema } from "#/arrange/group/cli-schema";
+import { presentArrangeGroupResult } from "#/arrange/group/output";
+import { suggestCnGroupsFromCli } from "#/arrange/group/suggest";
+import { formatArrangeAnalyzeJsonOutput } from "#/arrange/inspect/cli-result";
+import { arrangeAnalyzeDirectoryRequestSchema } from "#/arrange/inspect/cli-schema";
+import { presentAnalyzeReport } from "#/arrange/inspect/output";
+import { runArrangeInspect } from "#/arrange/inspect/run";
+import { prepareArrangeWorkspace } from "#/arrange/prepare";
+import { exitCodeForArrangeResult, formatArrangeJsonOutput } from "#/arrange/regroup/cli-result";
+import { arrangeRunRequestSchema } from "#/arrange/regroup/cli-schema";
+import { presentArrangeResult, presentGroupFilePreviewFromWork } from "#/arrange/regroup/output";
+import { runArrange } from "#/arrange/regroup/run";
+import { formatArrangeSimplifyJsonOutput } from "#/arrange/simplify/cli-result";
+import { arrangeSimplifyRunRequestSchema } from "#/arrange/simplify/cli-schema";
+import { presentSimplifyResult } from "#/arrange/simplify/output";
+import { runArrangeSimplify } from "#/arrange/simplify/run";
+import { applyCommandPipeline, registerPipelineSubcommand } from "#/core/cli/command-pipeline";
+import { consumeCliAppError } from "#/core/cli/result-handle";
+import { CLI_EXIT_SUCCESS } from "#/core/exit-codes";
 import { nodeFilesystem } from "#/core/filesystem/node";
 import { logger } from "#/core/logger";
 import { parseWithSchema } from "#/core/schema-parse";
+const targetHelp = "Directory or file (default: nearest package directory from cwd)";
+const prepareWorkspace = (fs, input) => prepareArrangeWorkspace(fs, { currentWorkingDirectory: input.currentWorkingDirectory, rawTarget: input.rawArg });
+const regroupPipeline = {
+    positional: { name: "[target]", help: targetHelp },
+    schema: arrangeRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Preview suggested replacements without writing files", false);
+        command.option("--with-classname, --with-class-name", "Append className as final cn() argument", false);
+        command.option("--cn-import <spec>", "Override module specifier when adding cn import");
+    },
+    prepare: prepareWorkspace,
+    buildRequest: ({ prelude, opts }) => ({
+        rootDir: prelude.rootDir,
+        targetPath: prelude.resolvedTarget,
+        write: !opts.dryRun,
+        withClassName: opts.withClassName,
+        cnImport: opts.cnImport,
+        config: prelude.config.arrange ?? {},
+    }),
+    run: (fs, request) => runArrange(fs, request),
+    presentHuman: ({ result, opts }) => {
+        // Dry-run previews are human-only; the --json summary omits the non-serializable plans.
+        if (opts.dryRun) {
+            for (const plan of result.previewPlans) {
+                presentGroupFilePreviewFromWork(plan);
+            }
+        }
+        presentArrangeResult(result, !opts.dryRun);
+    },
+    formatJson: ({ result, opts }) => formatArrangeJsonOutput(result, !opts.dryRun),
+    exitCode: exitCodeForArrangeResult,
+};
+const inspectPipeline = {
+    name: "inspect",
+    description: "Report long strings, nested cn in tv(), and related findings (read-only)",
+    positional: { name: "[target]", help: targetHelp },
+    jsonHelp: "Print one JSON object on stdout instead of a human report",
+    schema: arrangeAnalyzeDirectoryRequestSchema,
+    prepare: prepareWorkspace,
+    buildRequest: ({ prelude }) => ({ analyzeRootPath: prelude.resolvedTarget }),
+    run: async (fs, request) => runArrangeInspect(fs, request.analyzeRootPath),
+    presentHuman: ({ result, prelude }) => {
+        presentAnalyzeReport(prelude.resolvedTarget, result);
+    },
+    formatJson: ({ result, prelude }) => formatArrangeAnalyzeJsonOutput(prelude.resolvedTarget, result),
+    exitCode: () => CLI_EXIT_SUCCESS,
+};
+const simplifyPipeline = {
+    name: "simplify",
+    description: "Flatten grouped arrays and static-only cn() calls back to plain strings in tv() slots",
+    positional: { name: "[target]", help: targetHelp },
+    schema: arrangeSimplifyRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Show what simplify would change without writing files", false);
+        command.option("--fold-variant-classname, --fold-variant-class-name", "Fold cn() overrides into a variant function's className option (uses the TypeScript type server)", false);
+    },
+    prepare: prepareWorkspace,
+    buildRequest: ({ prelude, opts }) => ({
+        targetPath: prelude.resolvedTarget,
+        write: !opts.dryRun,
+        foldVariantClassName: opts.foldVariantClassName,
+    }),
+    run: (fs, request) => runArrangeSimplify(fs, request),
+    presentHuman: ({ result, opts }) => {
+        presentSimplifyResult(result, !opts.dryRun);
+    },
+    formatJson: ({ result, opts }) => formatArrangeSimplifyJsonOutput(result, !opts.dryRun),
+    exitCode: () => CLI_EXIT_SUCCESS,
+};
 /**
  * Creates the `arrange` command and its subcommands.
  *
@@ -23,103 +101,12 @@ export function createArrangeCommand() {
         .description("Regroup Tailwind classes in cn() / tv() calls in render-pipeline order")
         // The parent action shares option names (--json) with subcommands; positional
         // options ensure tokens after a subcommand bind to that subcommand, not the parent.
-        .enablePositionalOptions()
-        .argument("[target]", "Directory or file (default: nearest package directory from cwd)")
-        .option("--dry-run", "Preview suggested replacements without writing files", false)
-        .option("--with-classname, --with-class-name", "Append className as final cn() argument", false)
-        .option("--cn-import <spec>", "Override module specifier when adding cn import")
-        .option("--json", "Print one JSON object on stdout (suppresses human progress)", false)
-        .action(async (target, opts) => {
-        const write = !opts.dryRun;
-        const prelude = await prepareArrangeWorkspace(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { resolvedTarget, rootDir, config } = prelude.value;
-        const parsed = parseWithSchema(arrangeSyncRunRequestSchema, {
-            rootDir,
-            targetPath: resolvedTarget,
-            write,
-            withClassName: opts.withClassName,
-            cnImport: opts.cnImport,
-            config: config.arrange ?? {},
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        await runCliResultAsync(runArrangeSync(nodeFilesystem, parsed.value), (value) => {
-            if (!write) {
-                for (const plan of value.previewPlans) {
-                    printGroupFilePreviewFromWork(plan);
-                }
-            }
-            if (opts.json) {
-                logger.out(formatArrangeSyncJsonOutput(value, write));
-                return exitCodeForArrangeSyncResult(value);
-            }
-            printSyncResult(value, write);
-            return exitCodeForArrangeSyncResult(value);
-        });
-    });
-    cmd
-        .command("inspect")
-        .description("Report long strings, nested cn in tv(), and related findings (read-only)")
-        .argument("[target]", "Directory or file (default: nearest package directory from cwd)")
-        .option("--json", "Print one JSON object on stdout instead of a human report", false)
-        .action(async (target, opts) => {
-        const prelude = await prepareArrangeWorkspace(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { resolvedTarget } = prelude.value;
-        const parsed = parseWithSchema(arrangeAnalyzeDirectoryRequestSchema, {
-            analyzeRootPath: resolvedTarget,
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        const outcome = analyzeDirectory(nodeFilesystem, parsed.value.analyzeRootPath);
-        if (!consumeCliAppError(outcome)) {
-            return;
-        }
-        if (opts.json) {
-            logger.out(formatArrangeAnalyzeJsonOutput(resolvedTarget, outcome.value));
-        }
-        else {
-            printAnalyzeReport(resolvedTarget, outcome.value);
-        }
-    });
-    cmd
-        .command("simplify")
-        .description("Flatten grouped arrays and static-only cn() calls back to plain strings in tv() slots")
-        .argument("[target]", "Directory or file (default: nearest package directory from cwd)")
-        .option("--dry-run", "Show what simplify would change without writing files", false)
-        .option("--json", "Print one JSON object on stdout (suppresses human progress)", false)
-        .action(async (target, opts) => {
-        const write = !opts.dryRun;
-        const prelude = await prepareArrangeWorkspace(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { resolvedTarget } = prelude.value;
-        await runCliResultAsync(runArrangeSimplify(nodeFilesystem, { targetPath: resolvedTarget, write }), (value) => {
-            if (opts.json) {
-                logger.out(JSON.stringify({ schemaVersion: 1, ok: true, write, result: value }));
-                return CLI_EXIT_SUCCESS;
-            }
-            printSimplifyResult(value, write);
-            return CLI_EXIT_SUCCESS;
-        });
-    });
+        .enablePositionalOptions();
+    applyCommandPipeline(cmd, nodeFilesystem, regroupPipeline);
+    registerPipelineSubcommand(cmd, nodeFilesystem, inspectPipeline);
+    registerPipelineSubcommand(cmd, nodeFilesystem, simplifyPipeline);
+    // `group` is a pure token-string transform — no workspace prelude, a variadic positional — so it
+    // does not fit the workspace pipeline and stays wired by hand.
     cmd
         .command("group")
         .description("Try grouping on a pasted class string (stdout: cn(...) or tv array with --tv)")
@@ -141,31 +128,8 @@ export function createArrangeCommand() {
             logger.out(formatArrangeGroupJsonOutput(output));
         }
         else {
-            logger.out(output.primaryLine);
-            logger.out(output.bucketsCommentLine);
+            presentArrangeGroupResult(output);
         }
     });
     return cmd;
-}
-function formatArrangeAnalyzeJsonOutput(analyzeRootPath, report) {
-    return JSON.stringify({ schemaVersion: 1, analyzeRootPath, report });
-}
-function formatArrangeSyncJsonOutput(result, write) {
-    const { previewPlans: _plans, ...serializableResult } = result;
-    return JSON.stringify({
-        schemaVersion: 1,
-        ok: result.hookError === null,
-        write,
-        result: serializableResult,
-    });
-}
-function formatArrangeGroupJsonOutput(output) {
-    return JSON.stringify({
-        schemaVersion: 1,
-        primaryLine: output.primaryLine,
-        bucketsCommentLine: output.bucketsCommentLine,
-    });
-}
-function exitCodeForArrangeSyncResult(result) {
-    return result.hookError !== null ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
 }

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

@@ -0,0 +1,394 @@
+/**
+ * Pure-domain AST shapes for arrange analysis. No TypeScript compiler types.
+ * Positions mirror `getStart(sourceFile)` / `getEnd()` semantics from translation.
+ *
+ * @since 0.3.16-canary.0
+ */
+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
+}
+/**
+ * The binary operators the domain AST distinguishes.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare enum DomainBinaryOperator {
+    Plus = 0,
+    Other = 1
+}
+/**
+ * The pure-domain counterpart of a parsed source file.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainSourceFile {
+    readonly fileName: string;
+    readonly text: string;
+    readonly statements: ReadonlyArray<DomainAstNode>;
+}
+interface DomainNodeBase {
+    readonly kind: DomainSyntaxKind;
+    readonly pos: number;
+    readonly end: number;
+    readonly parent: DomainAstNode | null;
+}
+/**
+ * A node kind the translator does not model, retained only for its children.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainUnknownAstNode extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.Unknown;
+    readonly children: ReadonlyArray<DomainAstNode>;
+}
+/**
+ * An identifier node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainIdentifier extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.Identifier;
+    readonly text: string;
+}
+/**
+ * A string literal node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainStringLiteral extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.StringLiteral;
+    readonly text: string;
+}
+/**
+ * A template literal without substitutions.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainNoSubstitutionTemplateLiteral extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.NoSubstitutionTemplateLiteral;
+    readonly text: string;
+}
+/**
+ * An `import` declaration node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainImportDeclaration extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ImportDeclaration;
+    readonly importClause: DomainImportClause | undefined;
+    readonly moduleSpecifier: DomainAstNode;
+}
+/**
+ * The clause of an import declaration — default name plus named or namespace bindings.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainImportClause extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ImportClause;
+    readonly isTypeOnly: boolean;
+    readonly name: DomainIdentifier | undefined;
+    readonly namedBindings: DomainNamedImports | DomainNamespaceImport | undefined;
+}
+/**
+ * The named-bindings list of an import clause.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainNamedImports extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.NamedImports;
+    readonly elements: ReadonlyArray<DomainImportSpecifier>;
+}
+/**
+ * A namespace (`* as name`) import binding.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainNamespaceImport extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.NamespaceImport;
+    readonly name: DomainIdentifier;
+}
+/**
+ * A single named-import specifier.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainImportSpecifier extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ImportSpecifier;
+    readonly name: DomainIdentifier;
+    readonly propertyName: DomainIdentifier | undefined;
+}
+/**
+ * A call expression node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainCallExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.CallExpression;
+    readonly expression: DomainAstNode;
+    readonly arguments: ReadonlyArray<DomainAstNode>;
+}
+/**
+ * A property access (`object.name`) node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainPropertyAccessExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.PropertyAccessExpression;
+    readonly expression: DomainAstNode;
+    readonly name: DomainIdentifier;
+}
+/**
+ * An object literal node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainObjectLiteralExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ObjectLiteralExpression;
+    readonly properties: ReadonlyArray<DomainAstNode>;
+}
+/**
+ * A `name: value` property inside an object literal.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainPropertyAssignment extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.PropertyAssignment;
+    readonly name: DomainAstNode;
+    readonly initializer: DomainAstNode;
+}
+/**
+ * An array literal node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainArrayLiteralExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ArrayLiteralExpression;
+    readonly elements: ReadonlyArray<DomainAstNode>;
+}
+/**
+ * A spread (`...expression`) element node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainSpreadElement extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.SpreadElement;
+    readonly expression: DomainAstNode;
+}
+/**
+ * A parenthesized expression node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainParenthesizedExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ParenthesizedExpression;
+    readonly expression: DomainAstNode;
+}
+/**
+ * An `as` type-assertion node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainAsExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.AsExpression;
+    readonly expression: DomainAstNode;
+}
+/**
+ * A `satisfies` expression node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainSatisfiesExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.SatisfiesExpression;
+    readonly expression: DomainAstNode;
+}
+/**
+ * A non-null assertion (`expression!`) node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainNonNullExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.NonNullExpression;
+    readonly expression: DomainAstNode;
+}
+/**
+ * A ternary conditional node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainConditionalExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ConditionalExpression;
+    readonly condition: DomainAstNode;
+    readonly whenTrue: DomainAstNode;
+    readonly whenFalse: DomainAstNode;
+}
+/**
+ * A binary expression node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainBinaryExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.BinaryExpression;
+    readonly left: DomainAstNode;
+    readonly operator: DomainBinaryOperator;
+    readonly right: DomainAstNode;
+}
+/**
+ * An expression statement node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainExpressionStatement extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.ExpressionStatement;
+    readonly expression: DomainAstNode;
+}
+/**
+ * A JSX attribute node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainJsxAttribute extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.JsxAttribute;
+    readonly name: DomainAstNode;
+    readonly initializer: DomainAstNode | undefined;
+}
+/**
+ * A JSX expression container node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export interface DomainJsxExpression extends DomainNodeBase {
+    readonly kind: DomainSyntaxKind.JsxExpression;
+    readonly expression: DomainAstNode | undefined;
+}
+/**
+ * The union of every node shape the domain AST models.
+ *
+ * @since 0.3.16-canary.0
+ */
+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;
+/**
+ * A literal node that can carry a Tailwind class string.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type DomainTailwindClassLiteral = DomainStringLiteral | DomainNoSubstitutionTemplateLiteral;
+/**
+ * Narrows a node to `DomainIdentifier`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainIdentifier(node: DomainAstNode): node is DomainIdentifier;
+/**
+ * Narrows a node to `DomainStringLiteral`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainStringLiteral(node: DomainAstNode): node is DomainStringLiteral;
+/**
+ * Narrows a node to a literal that can carry Tailwind classes.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainTailwindClassLiteral(node: DomainAstNode): node is DomainTailwindClassLiteral;
+/**
+ * Narrows a node to `DomainImportDeclaration`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainImportDeclaration(node: DomainAstNode): node is DomainImportDeclaration;
+/**
+ * Narrows a node to `DomainNamedImports`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainNamedImports(node: DomainAstNode): node is DomainNamedImports;
+/**
+ * Narrows a node to `DomainNamespaceImport`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainNamespaceImport(node: DomainAstNode): node is DomainNamespaceImport;
+/**
+ * Narrows a node to `DomainCallExpression`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainCallExpression(node: DomainAstNode): node is DomainCallExpression;
+/**
+ * Narrows a node to `DomainObjectLiteralExpression`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainObjectLiteralExpression(node: DomainAstNode): node is DomainObjectLiteralExpression;
+/**
+ * Narrows a node to `DomainPropertyAssignment`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainPropertyAssignment(node: DomainAstNode): node is DomainPropertyAssignment;
+/**
+ * Narrows a node to `DomainArrayLiteralExpression`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainArrayLiteralExpression(node: DomainAstNode): node is DomainArrayLiteralExpression;
+/**
+ * Narrows a node to `DomainSpreadElement`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainSpreadElement(node: DomainAstNode): node is DomainSpreadElement;
+/**
+ * Narrows a node to `DomainPropertyAccessExpression`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainPropertyAccessExpression(node: DomainAstNode): node is DomainPropertyAccessExpression;
+/**
+ * Narrows a node to `DomainJsxAttribute`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainJsxAttribute(node: DomainAstNode): node is DomainJsxAttribute;
+/**
+ * Narrows a node to `DomainJsxExpression`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isDomainJsxExpression(node: DomainAstNode): node is DomainJsxExpression;
+/**
+ * Visits each direct child of a domain node.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function forEachDomainChild(node: DomainAstNode, visit: (child: DomainAstNode) => void): void;
+/**
+ * Resolves the one-based line number of a position in source text.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function lineOfSourcePosition(sourceText: string, pos: number): number;
+export {};

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

@@ -0,0 +1,26 @@
+import type { DomainAstNode } from "#/arrange/domain/ast/ast-node";
+import type { ForEachStringLiteralInClassExpressionOptions, TailwindClassLiteral } from "#/arrange/domain/types";
+/**
+ * Visits every static class literal reachable inside a class expression.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function forEachStringLiteralInClassExpression(expr: DomainAstNode, sink: (classLiteral: TailwindClassLiteral) => void, depth?: number, options?: ForEachStringLiteralInClassExpressionOptions): void;
+/**
+ * Checks whether a literal sits directly inside an array literal, where splitting it apart is unsafe.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function isUnsafeLiteralForCnStyleApplySplit(classLiteral: TailwindClassLiteral): boolean;
+/**
+ * The walk options for building the `cn` apply pool — conditional branches are never descended into.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const CN_APPLY_LITERAL_WALK_OPTS: ForEachStringLiteralInClassExpressionOptions;
+/**
+ * Collects the static class literals in `cn()` arguments that are safe to regroup.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function collectUnconditionalTailwindLiteralsFromCnArguments(args: ReadonlyArray<DomainAstNode>): Array<TailwindClassLiteral>;

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

@@ -0,0 +1,8 @@
+import type { DomainJsxAttribute } from "#/arrange/domain/ast/ast-node";
+import type { JsxClassNameStatic } from "#/arrange/domain/types";
+/**
+ * Extracts the static literal of a JSX `className` attribute, or `undefined` when it is not static.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function jsxClassNameStaticLiteral(jsxClassNameAttribute: DomainJsxAttribute): JsxClassNameStatic | undefined;