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

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

@@ -0,0 +1,233 @@
+import { suggestCnGroups, summarizeGroupBucketLabels } from "../../domain/grouping.domain.mjs";
+import { formatArray, formatCnCall } from "../../domain/source-text-formatters.formatter.mjs";
+import { injectable } from "@codefast/di";
+//#region src/lib/arrange/application/use-cases/suggest-cn-groups.use-case.ts
+function toPrimitive(input, hint) {
+	if (typeof input !== "object" || input === null) return input;
+	var prim = input[Symbol.toPrimitive];
+	if (prim !== void 0) {
+		var res = prim.call(input, hint || "default");
+		if (typeof res !== "object") return res;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (hint === "string" ? String : Number)(input);
+}
+function toPropertyKey(arg) {
+	var key = toPrimitive(arg, "string");
+	return typeof key === "symbol" ? key : String(key);
+}
+function checkInRHS(value) {
+	if (Object(value) !== value) throw TypeError("right-hand side of 'in' should be an object, got " + (value !== null ? typeof value : "null"));
+	return value;
+}
+function setFunctionName(fn, name, prefix) {
+	if (typeof name === "symbol") {
+		name = name.description;
+		name = name ? "[" + name + "]" : "";
+	}
+	try {
+		Object.defineProperty(fn, "name", {
+			configurable: true,
+			value: prefix ? prefix + " " + name : name
+		});
+	} catch (_) {}
+	return fn;
+}
+function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis, instanceBrand, parentClass) {
+	var symbolMetadata = Symbol.metadata || Symbol.for("Symbol.metadata");
+	var defineProperty = Object.defineProperty;
+	var create = Object.create;
+	var metadata;
+	var existingNonFields = [create(null), create(null)];
+	var hasClassDecs = classDecs.length;
+	var _;
+	function createRunInitializers(initializers, useStaticThis, hasValue) {
+		return function(thisArg, value) {
+			if (useStaticThis) {
+				value = thisArg;
+				thisArg = targetClass;
+			}
+			for (var i = 0; i < initializers.length; i++) value = initializers[i].apply(thisArg, hasValue ? [value] : []);
+			return hasValue ? value : thisArg;
+		};
+	}
+	function assertCallable(fn, hint1, hint2, throwUndefined) {
+		if (typeof fn !== "function") {
+			if (throwUndefined || fn !== void 0) throw new TypeError(hint1 + " must " + (hint2 || "be") + " a function" + (throwUndefined ? "" : " or undefined"));
+		}
+		return fn;
+	}
+	function applyDec(Class, decInfo, decoratorsHaveThis, name, kind, initializers, ret, isStatic, isPrivate, isField, hasPrivateBrand) {
+		function assertInstanceIfPrivate(target) {
+			if (!hasPrivateBrand(target)) throw new TypeError("Attempted to access private element on non-instance");
+		}
+		var decs = [].concat(decInfo[0]);
+		var decVal = decInfo[3];
+		var isClass = !ret;
+		var isAccessor = kind === 1;
+		var isGetter = kind === 3;
+		var isSetter = kind === 4;
+		var isMethod = kind === 2;
+		function bindPropCall(name, useStaticThis, before) {
+			return function(_this, value) {
+				if (useStaticThis) {
+					value = _this;
+					_this = Class;
+				}
+				if (before) before(_this);
+				return desc[name].call(_this, value);
+			};
+		}
+		var desc1 = {};
+		var init = [];
+		var key = isGetter ? "get" : isSetter || isAccessor ? "set" : "value";
+		if (!isClass) {
+			if (isPrivate) {
+				if (isField || isAccessor) desc1 = {
+					get: setFunctionName(function() {
+						return decVal(this);
+					}, name, "get"),
+					set: function(value) {
+						decInfo[4](this, value);
+					}
+				};
+				else desc1[key] = decVal;
+				if (!isField) setFunctionName(desc1[key], name, isMethod ? "" : key);
+			} else if (!isField) desc1 = Object.getOwnPropertyDescriptor(Class, name);
+			if (!isField && !isPrivate) {
+				_ = existingNonFields[+isStatic][name];
+				if (_ && (_ ^ kind) !== 7) throw new Error("Decorating two elements with the same name (" + desc1[key].name + ") is not supported yet");
+				existingNonFields[+isStatic][name] = kind < 3 ? 1 : kind;
+			}
+		}
+		var newValue = Class;
+		for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) {
+			var dec = assertCallable(decs[i], "A decorator", "be", true);
+			var decThis = decoratorsHaveThis ? decs[i - 1] : void 0;
+			var decoratorFinishedRef = {};
+			var ctx = {
+				kind: [
+					"field",
+					"accessor",
+					"method",
+					"getter",
+					"setter",
+					"class"
+				][kind],
+				name,
+				metadata,
+				addInitializer: (function(decoratorFinishedRef, initializer) {
+					if (decoratorFinishedRef.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+					assertCallable(initializer, "An initializer", "be", true);
+					initializers.push(initializer);
+				}).bind(null, decoratorFinishedRef)
+			};
+			if (isClass) {
+				_ = dec.call(decThis, newValue, ctx);
+				decoratorFinishedRef.v = 1;
+				if (assertCallable(_, "class decorators", "return")) newValue = _;
+				continue;
+			}
+			ctx.static = isStatic;
+			ctx.private = isPrivate;
+			_ = ctx.access = { has: isPrivate ? hasPrivateBrand.bind() : function(target) {
+				return name in target;
+			} };
+			if (!isSetter) _.get = isPrivate ? isMethod ? function(_this) {
+				assertInstanceIfPrivate(_this);
+				return desc1.value;
+			} : bindPropCall("get", 0, assertInstanceIfPrivate) : function(target) {
+				return target[name];
+			};
+			if (!isMethod && !isGetter) _.set = isPrivate ? bindPropCall("set", 0, assertInstanceIfPrivate) : function(target, value) {
+				target[name] = value;
+			};
+			newValue = dec.call(decThis, isAccessor ? {
+				get: desc1.get,
+				set: desc1.set
+			} : desc1[key], ctx);
+			decoratorFinishedRef.v = 1;
+			if (isAccessor) {
+				if (typeof newValue === "object" && newValue) {
+					if (_ = assertCallable(newValue.get, "accessor.get")) desc1.get = _;
+					if (_ = assertCallable(newValue.set, "accessor.set")) desc1.set = _;
+					if (_ = assertCallable(newValue.init, "accessor.init")) init.unshift(_);
+				} else if (newValue !== void 0) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+			} else if (assertCallable(newValue, (isField ? "field" : "method") + " decorators", "return")) if (isField) init.unshift(newValue);
+			else desc1[key] = newValue;
+		}
+		if (kind < 2) ret.push(createRunInitializers(init, isStatic, 1), createRunInitializers(initializers, isStatic, 0));
+		if (!isField && !isClass) if (isPrivate) if (isAccessor) ret.splice(-1, 0, bindPropCall("get", isStatic), bindPropCall("set", isStatic));
+		else ret.push(isMethod ? desc1[key] : assertCallable.call.bind(desc1[key]));
+		else defineProperty(Class, name, desc1);
+		return newValue;
+	}
+	function applyMemberDecs() {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var pushInitializers = function(initializers) {
+			if (initializers) ret.push(createRunInitializers(initializers));
+		};
+		var applyMemberDecsOfKind = function(isStatic, isField) {
+			for (var i = 0; i < memberDecs.length; i++) {
+				var decInfo = memberDecs[i];
+				var kind = decInfo[1];
+				var kindOnly = kind & 7;
+				if ((kind & 8) == isStatic && !kindOnly == isField) {
+					var name = decInfo[2];
+					var isPrivate = !!decInfo[3];
+					var decoratorsHaveThis = kind & 16;
+					applyDec(isStatic ? targetClass : targetClass.prototype, decInfo, decoratorsHaveThis, isPrivate ? "#" + name : toPropertyKey(name), kindOnly, kindOnly < 2 ? [] : isStatic ? staticInitializers = staticInitializers || [] : protoInitializers = protoInitializers || [], ret, !!isStatic, isPrivate, isField, isStatic && isPrivate ? function(_) {
+						return checkInRHS(_) === targetClass;
+					} : instanceBrand);
+				}
+			}
+		};
+		applyMemberDecsOfKind(8, 0);
+		applyMemberDecsOfKind(0, 0);
+		applyMemberDecsOfKind(8, 1);
+		applyMemberDecsOfKind(0, 1);
+		pushInitializers(protoInitializers);
+		pushInitializers(staticInitializers);
+		return ret;
+	}
+	function defineMetadata(Class) {
+		return defineProperty(Class, symbolMetadata, {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	if (parentClass !== void 0) metadata = parentClass[symbolMetadata];
+	metadata = create(metadata == null ? null : metadata);
+	_ = applyMemberDecs();
+	if (!hasClassDecs) defineMetadata(targetClass);
+	return {
+		e: _,
+		get c() {
+			var initializers = [];
+			return hasClassDecs && [defineMetadata(targetClass = applyDec(targetClass, [classDecs], classDecsHaveThis, targetClass.name, 5, initializers)), createRunInitializers(initializers, 1)];
+		}
+	};
+}
+let _dec, _initClass;
+_dec = injectable([]);
+let _SuggestCnGroupsUseCaseImpl;
+(class {
+	static {
+		({c: [_SuggestCnGroupsUseCaseImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	execute(request) {
+		const groups = suggestCnGroups(request.inlineClasses);
+		return {
+			primaryLine: request.emitTvStyleArray ? formatArray(groups) : formatCnCall(groups, { trailingClassName: request.trailingClassName }),
+			bucketsCommentLine: `// Buckets: ${JSON.stringify(summarizeGroupBucketLabels(groups))}`
+		};
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _SuggestCnGroupsUseCaseImpl as SuggestCnGroupsUseCaseImpl };

package/dist/lib/arrange/arrange.feature.module.mjs

@@ -0,0 +1,19 @@
+import { ArrangeCommand as _ArrangeCommand } from "../../commands/arrange.mjs";
+import { ArrangeModule } from "./arrange.module.mjs";
+import { ArrangePresentationModule } from "./arrange.presentation.module.mjs";
+import { COMMAND_TOKEN } from "../kernel/di/command.token.mjs";
+import { Module } from "@codefast/di";
+//#region src/lib/arrange/arrange.feature.module.ts
+const ArrangeFeatureModule = Module.create("cli-arrange-feature", (moduleBuilder) => {
+	moduleBuilder.import(ArrangePresentationModule, ArrangeModule);
+	moduleBuilder.bind(_ArrangeCommand).to(_ArrangeCommand).singleton();
+});
+function registerArrangeFeature(runtimeContainer) {
+	runtimeContainer.load(ArrangeFeatureModule);
+	runtimeContainer.bind(COMMAND_TOKEN).to(_ArrangeCommand).singleton().whenNamed("arrange");
+}
+function resolveArrangeCommand(runtimeContainer) {
+	return runtimeContainer.resolve(_ArrangeCommand);
+}
+//#endregion
+export { ArrangeFeatureModule, registerArrangeFeature, resolveArrangeCommand };

package/dist/lib/arrange/arrange.module.mjs

@@ -0,0 +1,27 @@
+import { AnalyzeDirectoryUseCaseToken, ArrangeFileProcessorToken, ArrangeTargetScannerToken, DomainSourceParserPortToken, FileWalkerPortToken, GroupFilePreviewPortToken, RunArrangeSyncUseCaseToken, SuggestCnGroupsUseCaseToken } from "./contracts/tokens.mjs";
+import { CliLoggerToken } from "../core/operational/contracts/tokens.mjs";
+import { ArrangeFileProcessorServiceImpl as _ArrangeFileProcessorServiceImpl } from "./application/services/arrange-file-processor.service.mjs";
+import { ArrangeTargetScannerServiceImpl as _ArrangeTargetScannerServiceImpl } from "./application/services/arrange-target-scanner.service.mjs";
+import { AnalyzeDirectoryUseCaseImpl as _AnalyzeDirectoryUseCaseImpl } from "./application/use-cases/analyze-directory.use-case.mjs";
+import { RunArrangeSyncUseCaseImpl as _RunArrangeSyncUseCaseImpl } from "./application/use-cases/run-arrange-sync.use-case.mjs";
+import { SuggestCnGroupsUseCaseImpl as _SuggestCnGroupsUseCaseImpl } from "./application/use-cases/suggest-cn-groups.use-case.mjs";
+import { DomainSourceParserAdapter as _DomainSourceParserAdapter } from "./infra/domain-source-parser.adapter.mjs";
+import { FileWalkerAdapter as _FileWalkerAdapter } from "./infra/file-walker.adapter.mjs";
+import { GroupFilePreviewPresenterAdapter as _GroupFilePreviewPresenterAdapter } from "./presentation/group-file-preview.presenter.mjs";
+import { withOptionalPortTelemetry } from "../core/infra/logging-decorator.adapter.mjs";
+import { InfraModule } from "../core/infra/infra.module.mjs";
+import { Module } from "@codefast/di";
+//#region src/lib/arrange/arrange.module.ts
+const ArrangeModule = Module.create("cli-arrange", (moduleBuilder) => {
+	moduleBuilder.import(InfraModule);
+	moduleBuilder.bind(FileWalkerPortToken).to(_FileWalkerAdapter).onActivation((ctx, implementation) => withOptionalPortTelemetry("FileWalkerPort", implementation, ctx.resolve(CliLoggerToken))).singleton();
+	moduleBuilder.bind(DomainSourceParserPortToken).to(_DomainSourceParserAdapter).onActivation((ctx, implementation) => withOptionalPortTelemetry("DomainSourceParserPort", implementation, ctx.resolve(CliLoggerToken))).singleton();
+	moduleBuilder.bind(GroupFilePreviewPortToken).to(_GroupFilePreviewPresenterAdapter).onActivation((ctx, implementation) => withOptionalPortTelemetry("GroupFilePreviewPort", implementation, ctx.resolve(CliLoggerToken))).singleton();
+	moduleBuilder.bind(AnalyzeDirectoryUseCaseToken).to(_AnalyzeDirectoryUseCaseImpl).singleton();
+	moduleBuilder.bind(ArrangeTargetScannerToken).to(_ArrangeTargetScannerServiceImpl).singleton();
+	moduleBuilder.bind(ArrangeFileProcessorToken).to(_ArrangeFileProcessorServiceImpl).singleton();
+	moduleBuilder.bind(RunArrangeSyncUseCaseToken).to(_RunArrangeSyncUseCaseImpl).singleton();
+	moduleBuilder.bind(SuggestCnGroupsUseCaseToken).to(_SuggestCnGroupsUseCaseImpl).singleton();
+});
+//#endregion
+export { ArrangeModule };

package/dist/lib/arrange/arrange.presentation.module.mjs

@@ -0,0 +1,13 @@
+import { PrepareArrangeOrchestratorToken, PresentAnalyzeReportPresenterToken } from "./contracts/tokens.mjs";
+import { PrepareArrangeOrchestrator as _PrepareArrangeOrchestrator } from "./presentation/prepare-arrange.orchestrator.mjs";
+import { PresentAnalyzeReportPresenterImpl as _PresentAnalyzeReportPresenterImpl } from "./presentation/present-analyze-report.presenter.mjs";
+import { PresentationModule } from "../core/presentation/presentation.module.mjs";
+import { Module } from "@codefast/di";
+//#region src/lib/arrange/arrange.presentation.module.ts
+const ArrangePresentationModule = Module.create("cli-arrange-presentation", (moduleBuilder) => {
+	moduleBuilder.import(PresentationModule);
+	moduleBuilder.bind(PrepareArrangeOrchestratorToken).to(_PrepareArrangeOrchestrator).singleton();
+	moduleBuilder.bind(PresentAnalyzeReportPresenterToken).to(_PresentAnalyzeReportPresenterImpl).singleton();
+});
+//#endregion
+export { ArrangePresentationModule };

package/dist/lib/arrange/contracts/tokens.mjs

@@ -0,0 +1,14 @@
+import { token } from "@codefast/di";
+//#region src/lib/arrange/contracts/tokens.ts
+const FileWalkerPortToken = token("FileWalkerPort");
+const DomainSourceParserPortToken = token("DomainSourceParserPort");
+const GroupFilePreviewPortToken = token("GroupFilePreviewPort");
+const ArrangeTargetScannerToken = token("ArrangeTargetScannerService");
+const ArrangeFileProcessorToken = token("ArrangeFileProcessorService");
+const AnalyzeDirectoryUseCaseToken = token("AnalyzeDirectoryUseCase");
+const RunArrangeSyncUseCaseToken = token("RunArrangeSyncUseCase");
+const SuggestCnGroupsUseCaseToken = token("SuggestCnGroupsUseCase");
+const PrepareArrangeOrchestratorToken = token("PrepareArrangeOrchestrator");
+const PresentAnalyzeReportPresenterToken = token("PresentAnalyzeReportPresenter");
+//#endregion
+export { AnalyzeDirectoryUseCaseToken, ArrangeFileProcessorToken, ArrangeTargetScannerToken, DomainSourceParserPortToken, FileWalkerPortToken, GroupFilePreviewPortToken, PrepareArrangeOrchestratorToken, PresentAnalyzeReportPresenterToken, RunArrangeSyncUseCaseToken, SuggestCnGroupsUseCaseToken };

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

@@ -0,0 +1,95 @@
+import "./constants.domain.mjs";
+import { forEachDomainChild, isDomainCallExpression, isDomainJsxAttribute, isDomainObjectLiteralExpression } from "./ast/ast-node.model.mjs";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, lineOf } from "./ast/ast-helpers.helper.mjs";
+import { forEachStringLiteralInClassExpression } from "./ast/collectors-cn.collector.mjs";
+import { tokenizeClassString } from "./tokenizer.util.mjs";
+import { collectCnCallsInsideTv, traverseTvObject } from "./ast/collectors-tv.collector.mjs";
+import { jsxClassNameStaticLiteral } from "./ast/collectors-jsx.collector.mjs";
+//#region src/lib/arrange/domain/arrange-analyze.service.ts
+/**
+* Rich domain: Tailwind/cn/tv analysis rules (counts, long literals, nested cn in tv).
+* Pure orchestration of domain collectors and invariants — no I/O.
+*/ const PREVIEW_MAX_LENGTH = 72;
+function previewText(text) {
+	return text.length > PREVIEW_MAX_LENGTH ? `${text.slice(0, PREVIEW_MAX_LENGTH)}…` : text;
+}
+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 >= 18) 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 >= 18) 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 >= 18) 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).
+*/ 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);
+}
+//#endregion
+export { accumulateAnalyzeReportForSourceFile, createEmptyAnalyzeReport };

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

@@ -0,0 +1,100 @@
+import { applyEditsDescending } from "../../shared/source-code/domain/text-edit.model.mjs";
+import { buildKnownCnTvBindings, unwrapCnInsideTvCallReplacement } from "./ast/ast-helpers.helper.mjs";
+import { listAllCnCallsInsideTvInSourceFile } from "./ast/collectors-tv.collector.mjs";
+import { collectGroupTargets, planGroupEditForTarget, targetReplaceStart } from "./ast/targets.model.mjs";
+//#region src/lib/arrange/domain/arrange-grouping.service.ts
+/**
+* Rich domain: plan Tailwind class grouping / cn-in-tv unwrap for a single file.
+* Pure: only DomainSourceFile, source strings, and options — no I/O.
+*/ function toUnwrapPlans(cnInTvCalls, sourceText) {
+	return cnInTvCalls.map((call) => {
+		const replacement = unwrapCnInsideTvCallReplacement(call, sourceText);
+		if (replacement === void 0) return;
+		return {
+			start: call.pos,
+			end: call.end,
+			replacement,
+			call
+		};
+	}).filter((plan) => plan !== void 0);
+}
+function buildGroupFileUnwrapState(domainSfInitial, sourceText) {
+	const cnInTvCalls = listAllCnCallsInsideTvInSourceFile(domainSfInitial, buildKnownCnTvBindings(domainSfInitial));
+	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);
+	return {
+		cnInTvCalls,
+		unwrapReplacementByCall,
+		unwrapEdits,
+		textAfterUnwrap: unwrapEdits.length > 0 ? applyEditsDescending(sourceText, [...unwrapEdits]) : sourceText,
+		cnInTvNoReplacement: cnInTvCalls.length - unwrapPlans.length
+	};
+}
+/**
+* `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.
+*/ 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 === void 0) 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
+	};
+}
+function groupFileDryRunNoEdits(filePath) {
+	return {
+		filePath,
+		totalFound: 0,
+		changed: 0
+	};
+}
+function groupFilePreviewTotals(work) {
+	return {
+		filePath: work.filePath,
+		totalFound: work.reportTotal,
+		changed: 0
+	};
+}
+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;
+}
+function groupFileEditsTouchJsxCn(work) {
+	return work.plannedGroupEdits.some((plannedEdit) => plannedEdit.jsxCn);
+}
+function countPersistedGroupFileEdits(work) {
+	return work.unwrapEdits.length + work.plannedGroupEdits.length;
+}
+function groupFileWorkHasNothingToReport(work) {
+	return work.editSitesCount === 0 && work.cnInTvNoReplacement === 0;
+}
+//#endregion
+export { buildGroupFileUnwrapState, countPersistedGroupFileEdits, groupFileDryRunNoEdits, groupFileEditsTouchJsxCn, groupFilePreviewTotals, groupFileWorkHasNothingToReport, mergeGroupFileBodyText, tryBuildGroupFileWorkPlan };

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

@@ -0,0 +1,89 @@
+import { EMPTY_CN_TV_BINDINGS } from "../constants.domain.mjs";
+import { applyEditsDescending, indentOfLineContaining } from "../../../shared/source-code/domain/text-edit.model.mjs";
+import { isDomainIdentifier, isDomainImportDeclaration, isDomainNamedImports, isDomainNamespaceImport, isDomainPropertyAccessExpression, isDomainStringLiteral, lineOfSourcePosition } from "./ast-node.model.mjs";
+//#region src/lib/arrange/domain/ast/ast-helpers.helper.ts
+/** Known module specifiers that export `cn` / `tv`. */ const KNOWN_CN_TV_MODULES = new Set([
+	"@codefast/tailwind-variants",
+	"clsx",
+	"class-variance-authority",
+	"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.
+*/ 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`.
+*/ function buildKnownCnTvBindings(sourceFile) {
+	const bindings = /* @__PURE__ */ 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;
+		if (!KNOWN_CN_TV_MODULES.has(moduleSpecifierText) && !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.
+*/ 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;
+}
+function propertyAssignmentNameText(prop) {
+	if (isDomainIdentifier(prop.name)) return prop.name.text;
+	if (isDomainStringLiteral(prop.name)) return prop.name.text;
+}
+function lineOf(sourceFile, node) {
+	return lineOfSourcePosition(sourceFile.text, node.pos);
+}
+/**
+* Replace `cn(...)` nested in `tv({...})` with a plain string (one arg) or a string
+* array (multiple args). Returns undefined when there are zero arguments.
+*/ function unwrapCnInsideTvCallReplacement(call, sourceText) {
+	const args = call.arguments;
+	if (args.length === 0) return;
+	const baseIndent = indentOfLineContaining(sourceText, call.pos);
+	const innerIndent = `${baseIndent}  `;
+	if (args.length === 1) {
+		const firstArg = args[0];
+		if (firstArg === void 0) return;
+		return sourceText.slice(firstArg.pos, firstArg.end);
+	}
+	const lines = ["["];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === void 0) throw new Error("invariant: unwrapCnInsideTvCall argument missing");
+		const piece = sourceText.slice(arg.pos, arg.end);
+		const comma = i < args.length - 1 || args.length > 1 ? "," : "";
+		lines.push(`${innerIndent}${piece}${comma}`);
+	}
+	lines.push(`${baseIndent}]`);
+	return lines.join("\n");
+}
+//#endregion
+export { KNOWN_CN_TV_MODULES, applyEditsDescending, buildKnownCnTvBindings, indentOfLineContaining, isCnOrTvIdentifier, lineOf, moduleLooksLikeCnTvReexport, propertyAssignmentNameText, unwrapCnInsideTvCallReplacement };