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

package/dist/lib/arrange/application/use-cases/suggest-cn-groups.use-case.d.ts

@@ -0,0 +1,7 @@
+import type { ArrangeSuggestGroupsRequest } from "#lib/arrange/application/requests/suggest-groups.request";
+export type ArrangeSuggestGroupsOutput = {
+    readonly primaryLine: string;
+    readonly bucketsCommentLine: string;
+};
+export declare function suggestCnGroupsForCli(request: ArrangeSuggestGroupsRequest): ArrangeSuggestGroupsOutput;
+//# sourceMappingURL=suggest-cn-groups.use-case.d.ts.map

package/dist/lib/arrange/application/use-cases/suggest-cn-groups.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest-cn-groups.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/application/use-cases/suggest-cn-groups.use-case.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,0DAA0D,CAAC;AAI5G,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;CACrC,CAAC;AAEF,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,2BAA2B,GACnC,0BAA0B,CAO5B"}

package/dist/lib/arrange/application/use-cases/suggest-cn-groups.use-case.js

@@ -0,0 +1,10 @@
+import { suggestCnGroups, summarizeGroupBucketLabels } from "#lib/arrange/domain/grouping.domain";
+import { formatArray, formatCnCall } from "#lib/arrange/domain/source-text-formatters.formatter";
+export function suggestCnGroupsForCli(request) {
+    const groups = suggestCnGroups(request.inlineClasses);
+    const primaryLine = request.emitTvStyleArray
+        ? formatArray(groups)
+        : formatCnCall(groups, { trailingClassName: request.trailingClassName });
+    const bucketsCommentLine = `// Buckets: ${JSON.stringify(summarizeGroupBucketLabels(groups))}`;
+    return { primaryLine, bucketsCommentLine };
+}

package/dist/lib/arrange/domain/arrange-analyze.service.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rich domain: Tailwind/cn/tv analysis rules (counts, long literals, nested cn in tv).
+ * Pure orchestration of domain collectors and invariants — no I/O.
+ */
+import type { AnalyzeReport } from "#lib/arrange/domain/types.domain";
+import { type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+export declare function createEmptyAnalyzeReport(): AnalyzeReport;
+/**
+ * Accumulates findings for one parsed source file into `report` (mutates report).
+ */
+export declare function accumulateAnalyzeReportForSourceFile(report: AnalyzeReport, domainSf: DomainSourceFile, sourceText: string, filePath: string): void;
+//# sourceMappingURL=arrange-analyze.service.d.ts.map

package/dist/lib/arrange/domain/arrange-analyze.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange-analyze.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/arrange-analyze.service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAatE,OAAO,EAIL,KAAK,gBAAgB,EAKtB,MAAM,wCAAwC,CAAC;AAQhD,wBAAgB,wBAAwB,IAAI,aAAa,CAUxD;AAmGD;;GAEG;AACH,wBAAgB,oCAAoC,CAClD,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,IAAI,CAeN"}

package/dist/lib/arrange/domain/arrange-analyze.service.js

@@ -0,0 +1,116 @@
+/**
+ * Rich domain: Tailwind/cn/tv analysis rules (counts, long literals, nested cn in tv).
+ * Pure orchestration of domain collectors and invariants — no I/O.
+ */
+import { LONG_STRING_TOKEN_THRESHOLD } from "#lib/arrange/domain/constants.domain";
+import { tokenizeClassString } from "#lib/arrange/domain/tokenizer.util";
+import { forEachStringLiteralInClassExpression } from "#lib/arrange/domain/ast/collectors-cn.collector";
+import { jsxClassNameStaticLiteral } from "#lib/arrange/domain/ast/collectors-jsx.collector";
+import { collectCnCallsInsideTv, traverseTvObject, } from "#lib/arrange/domain/ast/collectors-tv.collector";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, lineOf, } from "#lib/arrange/domain/ast/ast-helpers.helper";
+import { isDomainCallExpression, isDomainJsxAttribute, isDomainObjectLiteralExpression, forEachDomainChild, } from "#lib/arrange/domain/ast/ast-node.model";
+const PREVIEW_MAX_LENGTH = 72;
+function previewText(text) {
+    return text.length > PREVIEW_MAX_LENGTH ? `${text.slice(0, PREVIEW_MAX_LENGTH)}…` : text;
+}
+export function createEmptyAnalyzeReport() {
+    return {
+        files: 0,
+        cnCallExpressions: 0,
+        tvCallExpressions: 0,
+        cnInsideTvCalls: [],
+        longCnStringLiterals: [],
+        longTvStringLiterals: [],
+        longJsxClassNameLiterals: [],
+    };
+}
+function analyzeCnCall(domainSf, call, report) {
+    for (const arg of call.arguments) {
+        forEachStringLiteralInClassExpression(arg, (lit) => {
+            const text = lit.text;
+            const tokenCount = tokenizeClassString(text).length;
+            if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
+                report.longCnStringLiterals.push({
+                    file: domainSf.fileName,
+                    line: lineOf(domainSf, lit),
+                    tokenCount,
+                    preview: previewText(text),
+                });
+            }
+        });
+    }
+}
+function visitCallExpressionForArrangeAnalyze(callExpression, domainSf, sourceText, knownBindings, report) {
+    if (isCnOrTvIdentifier(callExpression.expression, "cn", knownBindings)) {
+        report.cnCallExpressions++;
+        analyzeCnCall(domainSf, callExpression, report);
+        return;
+    }
+    if (!isCnOrTvIdentifier(callExpression.expression, "tv", knownBindings)) {
+        return;
+    }
+    report.tvCallExpressions++;
+    const arg0 = callExpression.arguments[0];
+    if (!arg0 || !isDomainObjectLiteralExpression(arg0)) {
+        return;
+    }
+    for (const nestedCn of collectCnCallsInsideTv(domainSf, arg0, knownBindings, 0)) {
+        const src = sourceText.slice(nestedCn.pos, nestedCn.end);
+        report.cnInsideTvCalls.push({
+            file: domainSf.fileName,
+            line: lineOf(domainSf, nestedCn),
+            argCount: nestedCn.arguments.length,
+            preview: previewText(src),
+        });
+    }
+    traverseTvObject(domainSf, arg0, (classLiteral) => {
+        const text = classLiteral.text;
+        const tokenCount = tokenizeClassString(text).length;
+        if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
+            report.longTvStringLiterals.push({
+                file: domainSf.fileName,
+                line: lineOf(domainSf, classLiteral),
+                tokenCount,
+                preview: previewText(text),
+            });
+        }
+    }, 0, knownBindings);
+}
+function visitJsxAttributeForArrangeAnalyze(jsxClassAttribute, domainSf, filePath, report) {
+    if (!filePath.endsWith(".tsx")) {
+        return;
+    }
+    const parsed = jsxClassNameStaticLiteral(jsxClassAttribute);
+    if (!parsed) {
+        return;
+    }
+    const text = parsed.lit.text;
+    const tokenCount = tokenizeClassString(text).length;
+    if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
+        report.longJsxClassNameLiterals.push({
+            file: domainSf.fileName,
+            line: lineOf(domainSf, parsed.lit),
+            tokenCount,
+            preview: previewText(text),
+        });
+    }
+}
+/**
+ * Accumulates findings for one parsed source file into `report` (mutates report).
+ */
+export function accumulateAnalyzeReportForSourceFile(report, domainSf, sourceText, filePath) {
+    report.files++;
+    const knownBindings = buildKnownCnTvBindings(domainSf);
+    const visitTypeScriptSubtree = (tsNode) => {
+        if (isDomainCallExpression(tsNode)) {
+            visitCallExpressionForArrangeAnalyze(tsNode, domainSf, sourceText, knownBindings, report);
+        }
+        if (isDomainJsxAttribute(tsNode)) {
+            visitJsxAttributeForArrangeAnalyze(tsNode, domainSf, filePath, report);
+        }
+        forEachDomainChild(tsNode, visitTypeScriptSubtree);
+    };
+    for (const stmt of domainSf.statements) {
+        visitTypeScriptSubtree(stmt);
+    }
+}

package/dist/lib/arrange/domain/arrange-grouping.service.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Rich domain: plan Tailwind class grouping / cn-in-tv unwrap for a single file.
+ * Pure: only DomainSourceFile, source strings, and options — no I/O.
+ */
+import type { GroupFileResult, PlannedGroupEdit } from "#lib/arrange/domain/types.domain";
+import type { DomainCallExpression, DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+export type GroupFileUnwrapPlan = {
+    readonly start: number;
+    readonly end: number;
+    readonly replacement: string;
+    readonly call: DomainCallExpression;
+};
+export type GroupFileUnwrapState = {
+    readonly cnInTvCalls: readonly DomainCallExpression[];
+    readonly unwrapReplacementByCall: ReadonlyMap<DomainCallExpression, string>;
+    readonly unwrapEdits: readonly GroupFileUnwrapPlan[];
+    readonly textAfterUnwrap: string;
+    readonly cnInTvNoReplacement: number;
+};
+export type GroupFileWorkPlan = {
+    readonly filePath: string;
+    readonly sourceText: string;
+    readonly textAfterUnwrap: string;
+    readonly domainSfForLineNumbers: DomainSourceFile;
+    readonly domainSfGrouped: DomainSourceFile;
+    readonly cnInTvCalls: readonly DomainCallExpression[];
+    readonly unwrapReplacementByCall: ReadonlyMap<DomainCallExpression, string>;
+    readonly unwrapEdits: readonly GroupFileUnwrapPlan[];
+    readonly plannedGroupEdits: readonly PlannedGroupEdit[];
+    readonly cnInTvNoReplacement: number;
+    readonly reportTotal: number;
+    readonly editSitesCount: number;
+};
+export declare function buildGroupFileUnwrapState(domainSfInitial: DomainSourceFile, sourceText: string): GroupFileUnwrapState;
+/**
+ * `domainSfGrouped` must be a parse of `unwrap.textAfterUnwrap` (same `text` as source).
+ * Returns `null` when there is no cn-in-tv and no grouping targets.
+ */
+export declare function tryBuildGroupFileWorkPlan(input: {
+    readonly filePath: string;
+    readonly sourceText: string;
+    readonly domainSfInitial: DomainSourceFile;
+    readonly domainSfGrouped: DomainSourceFile;
+    readonly withClassName: boolean;
+    readonly unwrap: GroupFileUnwrapState;
+}): GroupFileWorkPlan | null;
+export declare function groupFileDryRunNoEdits(filePath: string): GroupFileResult;
+export declare function groupFilePreviewTotals(work: GroupFileWorkPlan): GroupFileResult;
+export declare function mergeGroupFileBodyText(work: GroupFileWorkPlan): string;
+export declare function groupFileEditsTouchJsxCn(work: GroupFileWorkPlan): boolean;
+export declare function countPersistedGroupFileEdits(work: GroupFileWorkPlan): number;
+export declare function groupFileWorkHasNothingToReport(work: GroupFileWorkPlan): boolean;
+//# sourceMappingURL=arrange-grouping.service.d.ts.map

package/dist/lib/arrange/domain/arrange-grouping.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange-grouping.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/arrange-grouping.service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAY1F,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,wCAAwC,CAAC;AAEhD,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACtD,QAAQ,CAAC,uBAAuB,EAAE,WAAW,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC;IAC5E,QAAQ,CAAC,WAAW,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACrD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,sBAAsB,EAAE,gBAAgB,CAAC;IAClD,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACtD,QAAQ,CAAC,uBAAuB,EAAE,WAAW,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC;IAC5E,QAAQ,CAAC,WAAW,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACrD,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC,CAAC;AAiBF,wBAAgB,yBAAyB,CACvC,eAAe,EAAE,gBAAgB,EACjC,UAAU,EAAE,MAAM,GACjB,oBAAoB,CAoBtB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;CACvC,GAAG,iBAAiB,GAAG,IAAI,CA+C3B;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAExE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,iBAAiB,GAAG,eAAe,CAM/E;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAWtE;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAEzE;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAE5E;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAEhF"}

package/dist/lib/arrange/domain/arrange-grouping.service.js

@@ -0,0 +1,106 @@
+/**
+ * Rich domain: plan Tailwind class grouping / cn-in-tv unwrap for a single file.
+ * Pure: only DomainSourceFile, source strings, and options — no I/O.
+ */
+import { applyEditsDescending, buildKnownCnTvBindings, unwrapCnInsideTvCallReplacement, } from "#lib/arrange/domain/ast/ast-helpers.helper";
+import { listAllCnCallsInsideTvInSourceFile } from "#lib/arrange/domain/ast/collectors-tv.collector";
+import { collectGroupTargets, planGroupEditForTarget, targetReplaceStart, } from "#lib/arrange/domain/ast/targets.model";
+function toUnwrapPlans(cnInTvCalls, sourceText) {
+    return cnInTvCalls
+        .map((call) => {
+        const replacement = unwrapCnInsideTvCallReplacement(call, sourceText);
+        if (replacement === undefined) {
+            return undefined;
+        }
+        return { start: call.pos, end: call.end, replacement, call };
+    })
+        .filter((plan) => plan !== undefined);
+}
+export function buildGroupFileUnwrapState(domainSfInitial, sourceText) {
+    const knownBindings = buildKnownCnTvBindings(domainSfInitial);
+    const cnInTvCalls = listAllCnCallsInsideTvInSourceFile(domainSfInitial, knownBindings);
+    const unwrapPlans = toUnwrapPlans(cnInTvCalls, sourceText);
+    const unwrapReplacementByCall = new Map(unwrapPlans.map((unwrapPlan) => [unwrapPlan.call, unwrapPlan.replacement]));
+    const unwrapEdits = unwrapPlans.filter((unwrapPlan) => sourceText.slice(unwrapPlan.start, unwrapPlan.end) !== unwrapPlan.replacement);
+    const textAfterUnwrap = unwrapEdits.length > 0 ? applyEditsDescending(sourceText, [...unwrapEdits]) : sourceText;
+    const cnInTvNoReplacement = cnInTvCalls.length - unwrapPlans.length;
+    return {
+        cnInTvCalls,
+        unwrapReplacementByCall,
+        unwrapEdits,
+        textAfterUnwrap,
+        cnInTvNoReplacement,
+    };
+}
+/**
+ * `domainSfGrouped` must be a parse of `unwrap.textAfterUnwrap` (same `text` as source).
+ * Returns `null` when there is no cn-in-tv and no grouping targets.
+ */
+export function tryBuildGroupFileWorkPlan(input) {
+    const { filePath, sourceText, domainSfInitial, domainSfGrouped, withClassName, unwrap } = input;
+    if (domainSfGrouped.text !== unwrap.textAfterUnwrap) {
+        throw new Error("Domain invariant: domainSfGrouped.text must match unwrap phase textAfterUnwrap");
+    }
+    const groupTargets = collectGroupTargets(domainSfGrouped, filePath);
+    if (unwrap.cnInTvCalls.length === 0 && groupTargets.length === 0) {
+        return null;
+    }
+    const sortedTargets = [...groupTargets].sort((leftTarget, rightTarget) => targetReplaceStart(rightTarget) - targetReplaceStart(leftTarget));
+    const plannedGroupEdits = [];
+    for (const groupTarget of sortedTargets) {
+        const plan = planGroupEditForTarget(groupTarget, unwrap.textAfterUnwrap, withClassName);
+        if (plan === undefined) {
+            continue;
+        }
+        if (unwrap.textAfterUnwrap.slice(plan.start, plan.end) === plan.replacement) {
+            continue;
+        }
+        plannedGroupEdits.push(plan);
+    }
+    const editSitesCount = unwrap.unwrapEdits.length + plannedGroupEdits.length;
+    const reportTotal = editSitesCount + unwrap.cnInTvNoReplacement;
+    return {
+        filePath,
+        sourceText,
+        textAfterUnwrap: unwrap.textAfterUnwrap,
+        domainSfForLineNumbers: domainSfInitial,
+        domainSfGrouped,
+        cnInTvCalls: unwrap.cnInTvCalls,
+        unwrapReplacementByCall: unwrap.unwrapReplacementByCall,
+        unwrapEdits: unwrap.unwrapEdits,
+        plannedGroupEdits,
+        cnInTvNoReplacement: unwrap.cnInTvNoReplacement,
+        reportTotal,
+        editSitesCount,
+    };
+}
+export function groupFileDryRunNoEdits(filePath) {
+    return { filePath, totalFound: 0, changed: 0 };
+}
+export function groupFilePreviewTotals(work) {
+    return {
+        filePath: work.filePath,
+        totalFound: work.reportTotal,
+        changed: 0,
+    };
+}
+export function mergeGroupFileBodyText(work) {
+    const groupEdits = work.plannedGroupEdits.map((plannedEdit) => ({
+        start: plannedEdit.start,
+        end: plannedEdit.end,
+        replacement: plannedEdit.replacement,
+        jsxCn: plannedEdit.jsxCn,
+    }));
+    return groupEdits.length > 0
+        ? applyEditsDescending(work.textAfterUnwrap, groupEdits)
+        : work.textAfterUnwrap;
+}
+export function groupFileEditsTouchJsxCn(work) {
+    return work.plannedGroupEdits.some((plannedEdit) => plannedEdit.jsxCn);
+}
+export function countPersistedGroupFileEdits(work) {
+    return work.unwrapEdits.length + work.plannedGroupEdits.length;
+}
+export function groupFileWorkHasNothingToReport(work) {
+    return work.editSitesCount === 0 && work.cnInTvNoReplacement === 0;
+}

package/dist/lib/arrange/domain/ast/ast-helpers.helper.d.ts

@@ -0,0 +1,28 @@
+import { applyEditsDescending, indentOfLineContaining } from "#lib/shared/source-code/domain/text-edit.model";
+import { type DomainAstNode, type DomainCallExpression, type DomainPropertyAssignment, type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+/** Known module specifiers that export `cn` / `tv`. */
+export declare const KNOWN_CN_TV_MODULES: Set<string>;
+/**
+ * True for typical shadcn-style re-exports: `./utils`, `@/lib/utils`, `…/utils/…`,
+ * or a dedicated `cn.ts` / `cn.tsx` module.
+ */
+export declare function moduleLooksLikeCnTvReexport(moduleSpecifier: string): boolean;
+/**
+ * Build a set of local binding names that are imported from a known cn/tv
+ * module in `sourceFile`.
+ */
+export declare function buildKnownCnTvBindings(sourceFile: DomainSourceFile): Set<string>;
+/**
+ * Returns true when `expr` is an identifier whose name matches `name` AND
+ * that name is listed in `knownBindings` from a recognized import.
+ */
+export declare function isCnOrTvIdentifier(expr: DomainAstNode, name: "cn" | "tv", knownBindings?: Set<string>): boolean;
+export declare function propertyAssignmentNameText(prop: DomainPropertyAssignment): string | undefined;
+export declare function lineOf(sourceFile: DomainSourceFile, node: DomainAstNode): number;
+export { applyEditsDescending, indentOfLineContaining };
+/**
+ * Replace `cn(...)` nested in `tv({...})` with a plain string (one arg) or a string
+ * array (multiple args). Returns undefined when there are zero arguments.
+ */
+export declare function unwrapCnInsideTvCallReplacement(call: DomainCallExpression, sourceText: string): string | undefined;
+//# sourceMappingURL=ast-helpers.helper.d.ts.map

package/dist/lib/arrange/domain/ast/ast-helpers.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-helpers.helper.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/ast-helpers.helper.ts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,gDAAgD,CAAC;AACxD,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EAQtB,MAAM,wCAAwC,CAAC;AAEhD,uDAAuD;AACvD,eAAO,MAAM,mBAAmB,aAU9B,CAAC;AAEH;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAY5E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,gBAAgB,GAAG,GAAG,CAAC,MAAM,CAAC,CAsChF;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,IAAI,GAAG,IAAI,EACjB,aAAa,GAAE,GAAG,CAAC,MAAM,CAAwB,GAChD,OAAO,CAWT;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,wBAAwB,GAAG,MAAM,GAAG,SAAS,CAQ7F;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM,CAEhF;AAED,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,CAAC;AAExD;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,oBAAoB,EAC1B,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,SAAS,CAsBpB"}

package/dist/lib/arrange/domain/ast/ast-helpers.helper.js

@@ -0,0 +1,130 @@
+import { EMPTY_CN_TV_BINDINGS } from "#lib/arrange/domain/constants.domain";
+import { applyEditsDescending, indentOfLineContaining, } from "#lib/shared/source-code/domain/text-edit.model";
+import { isDomainIdentifier, isDomainImportDeclaration, isDomainNamedImports, isDomainNamespaceImport, isDomainPropertyAccessExpression, isDomainStringLiteral, lineOfSourcePosition, } from "#lib/arrange/domain/ast/ast-node.model";
+/** Known module specifiers that export `cn` / `tv`. */
+export const KNOWN_CN_TV_MODULES = new Set([
+    "@codefast/tailwind-variants",
+    "clsx",
+    "class-variance-authority",
+    // Backward compatibility only: keep detection for existing user code that still imports
+    // from "tailwind-variants"; new code should prefer "@codefast/tailwind-variants".
+    "tailwind-variants",
+    "#lib/utils",
+    "~/lib/utils",
+    "@/lib/utils",
+]);
+/**
+ * True for typical shadcn-style re-exports: `./utils`, `@/lib/utils`, `…/utils/…`,
+ * or a dedicated `cn.ts` / `cn.tsx` module.
+ */
+export function moduleLooksLikeCnTvReexport(moduleSpecifier) {
+    const norm = moduleSpecifier.replace(/\\/g, "/");
+    if (/(?:^|[./])utils(?:\/|$)/.test(norm)) {
+        return true;
+    }
+    if (/\/utils\//.test(norm) || /\/utils$/.test(norm)) {
+        return true;
+    }
+    if (/(?:^|\/)cn\.tsx?$/.test(norm)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Build a set of local binding names that are imported from a known cn/tv
+ * module in `sourceFile`.
+ */
+export function buildKnownCnTvBindings(sourceFile) {
+    const bindings = new Set();
+    for (const stmt of sourceFile.statements) {
+        if (!isDomainImportDeclaration(stmt) || !stmt.importClause) {
+            continue;
+        }
+        if (stmt.importClause.isTypeOnly) {
+            continue;
+        }
+        const spec = stmt.moduleSpecifier;
+        if (!isDomainStringLiteral(spec)) {
+            continue;
+        }
+        const moduleSpecifierText = spec.text;
+        const isKnown = KNOWN_CN_TV_MODULES.has(moduleSpecifierText);
+        if (!isKnown && !moduleLooksLikeCnTvReexport(moduleSpecifierText)) {
+            continue;
+        }
+        const clause = stmt.importClause;
+        if (clause.name) {
+            bindings.add(clause.name.text);
+        }
+        const { namedBindings } = clause;
+        if (!namedBindings) {
+            continue;
+        }
+        if (isDomainNamedImports(namedBindings)) {
+            for (const namedImport of namedBindings.elements) {
+                bindings.add(namedImport.name.text);
+            }
+            continue;
+        }
+        if (isDomainNamespaceImport(namedBindings)) {
+            bindings.add(namedBindings.name.text);
+        }
+    }
+    return bindings;
+}
+/**
+ * Returns true when `expr` is an identifier whose name matches `name` AND
+ * that name is listed in `knownBindings` from a recognized import.
+ */
+export function isCnOrTvIdentifier(expr, name, knownBindings = EMPTY_CN_TV_BINDINGS) {
+    if (knownBindings.size === 0) {
+        return false;
+    }
+    if (isDomainIdentifier(expr) && expr.text === name) {
+        return knownBindings.has(expr.text);
+    }
+    if (isDomainPropertyAccessExpression(expr) && expr.name.text === name) {
+        return isDomainIdentifier(expr.expression) && knownBindings.has(expr.expression.text);
+    }
+    return false;
+}
+export function propertyAssignmentNameText(prop) {
+    if (isDomainIdentifier(prop.name)) {
+        return prop.name.text;
+    }
+    if (isDomainStringLiteral(prop.name)) {
+        return prop.name.text;
+    }
+    return undefined;
+}
+export function lineOf(sourceFile, node) {
+    return lineOfSourcePosition(sourceFile.text, node.pos);
+}
+export { applyEditsDescending, indentOfLineContaining };
+/**
+ * Replace `cn(...)` nested in `tv({...})` with a plain string (one arg) or a string
+ * array (multiple args). Returns undefined when there are zero arguments.
+ */
+export function unwrapCnInsideTvCallReplacement(call, sourceText) {
+    const args = call.arguments;
+    if (args.length === 0) {
+        return undefined;
+    }
+    const baseIndent = indentOfLineContaining(sourceText, call.pos);
+    const innerIndent = `${baseIndent}  `;
+    if (args.length === 1) {
+        const firstArg = args[0];
+        return sourceText.slice(firstArg.pos, firstArg.end);
+    }
+    const lines = ["["];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const piece = sourceText.slice(arg.pos, arg.end);
+        // Trailing comma on every element — intentional (Prettier-compatible style;
+        // keeps array diffs clean when arguments are later added or removed).
+        const comma = i < args.length - 1 || args.length > 1 ? "," : "";
+        lines.push(`${innerIndent}${piece}${comma}`);
+    }
+    lines.push(`${baseIndent}]`);
+    return lines.join("\n");
+}

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