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

package/dist/lib/arrange/infra/file-walker.adapter.mjs

@@ -0,0 +1,239 @@
+import { CliLoggerToken } from "../../core/operational/contracts/tokens.mjs";
+import { messageFromCaughtUnknown } from "../../core/application/utils/caught-unknown-message.util.mjs";
+import { walkTsxFiles } from "../../shared/source-code/infra/tsx-file-walk.adapter.mjs";
+import { inject, injectable } from "@codefast/di";
+//#region src/lib/arrange/infra/file-walker.adapter.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([inject(CliLoggerToken)]);
+let _FileWalkerAdapter;
+(class {
+	logger;
+	static {
+		({c: [_FileWalkerAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(logger) {
+		this.logger = logger;
+	}
+	walkTypeScriptFiles(rootDirectoryPath, fs) {
+		try {
+			return walkTsxFiles(rootDirectoryPath, fs);
+		} catch (caughtError) {
+			this.logger?.err(`[file-walker] ${messageFromCaughtUnknown(caughtError)}`);
+			throw caughtError;
+		}
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _FileWalkerAdapter as FileWalkerAdapter };

package/dist/lib/arrange/infra/merge-cn-literal-pool-for-test.test-helper.mjs

@@ -0,0 +1,18 @@
+import { isDomainCallExpression, isDomainExpressionStatement, isDomainIdentifier } from "../domain/ast/ast-node.model.mjs";
+import { collectUnconditionalTailwindLiteralsFromCnArguments } from "../domain/ast/collectors-cn.collector.mjs";
+import { parseDomainSourceFile } from "./ts-ast-translator.adapter.mjs";
+//#region src/lib/arrange/infra/merge-cn-literal-pool-for-test.test-helper.ts
+/**
+* Test / REPL helper: parse `callee(<snippet>)` and return merged unconditional literal text.
+* Lives in infra because parsing uses the TypeScript-backed translator.
+*/ function mergeCnUnconditionalLiteralPoolForTest(argsSnippet, options) {
+	const callee = options?.callee ?? "cn";
+	const stmt = parseDomainSourceFile("mergeCnUnconditionalLiteralPoolForTest.ts", `${callee}(${argsSnippet});`).statements[0];
+	if (stmt === void 0) throw new Error("expected one statement");
+	if (!isDomainExpressionStatement(stmt)) throw new Error("expected expression statement");
+	const call = stmt.expression;
+	if (!isDomainCallExpression(call) || !isDomainIdentifier(call.expression) || call.expression.text !== callee) throw new Error(`expected ${callee}(...) call`);
+	return collectUnconditionalTailwindLiteralsFromCnArguments(call.arguments).map((literal) => literal.text).join(" ");
+}
+//#endregion
+export { mergeCnUnconditionalLiteralPoolForTest };

package/dist/lib/arrange/infra/ts-ast-translator.adapter.mjs

@@ -0,0 +1,355 @@
+import { DomainBinaryOperator, DomainSyntaxKind } from "../domain/ast/ast-node.model.mjs";
+import ts from "typescript";
+//#region src/lib/arrange/infra/ts-ast-translator.adapter.ts
+/**
+* Anti-corruption layer: maps TypeScript compiler AST to arrange domain AST.
+* This module is the only place that imports `typescript` for arrange AST translation.
+*/ function translateUnknown(n, parent, sf) {
+	const pos = n.getStart(sf);
+	const end = n.getEnd();
+	const self = {
+		kind: DomainSyntaxKind.Unknown,
+		pos,
+		end,
+		parent,
+		children: []
+	};
+	const childList = [];
+	ts.forEachChild(n, (child) => {
+		childList.push(translateNode(child, self, sf));
+	});
+	return {
+		...self,
+		children: childList
+	};
+}
+function mapBinaryOperator(operatorToken) {
+	if (operatorToken.kind === ts.SyntaxKind.PlusToken) return DomainBinaryOperator.Plus;
+	return DomainBinaryOperator.Other;
+}
+function translateNode(n, parent, sf) {
+	const pos = n.getStart(sf);
+	const end = n.getEnd();
+	switch (n.kind) {
+		case ts.SyntaxKind.Identifier: {
+			const id = n;
+			return {
+				kind: DomainSyntaxKind.Identifier,
+				pos,
+				end,
+				parent,
+				text: id.text
+			};
+		}
+		case ts.SyntaxKind.StringLiteral: {
+			const lit = n;
+			return {
+				kind: DomainSyntaxKind.StringLiteral,
+				pos,
+				end,
+				parent,
+				text: lit.text
+			};
+		}
+		case ts.SyntaxKind.NoSubstitutionTemplateLiteral: {
+			const lit = n;
+			return {
+				kind: DomainSyntaxKind.NoSubstitutionTemplateLiteral,
+				pos,
+				end,
+				parent,
+				text: lit.text
+			};
+		}
+		case ts.SyntaxKind.ImportDeclaration: {
+			const decl = n;
+			const self = {
+				kind: DomainSyntaxKind.ImportDeclaration,
+				pos,
+				end,
+				parent,
+				importClause: void 0,
+				moduleSpecifier: void 0
+			};
+			if (decl.importClause) self.importClause = translateNode(decl.importClause, self, sf);
+			self.moduleSpecifier = translateNode(decl.moduleSpecifier, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.ImportClause: {
+			const clause = n;
+			const self = {
+				kind: DomainSyntaxKind.ImportClause,
+				pos,
+				end,
+				parent,
+				isTypeOnly: clause.isTypeOnly,
+				name: void 0,
+				namedBindings: void 0
+			};
+			if (clause.name) self.name = translateNode(clause.name, self, sf);
+			if (clause.namedBindings) self.namedBindings = translateNode(clause.namedBindings, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.NamedImports: {
+			const named = n;
+			const self = {
+				kind: DomainSyntaxKind.NamedImports,
+				pos,
+				end,
+				parent,
+				elements: []
+			};
+			const elements = [];
+			for (const element of named.elements) elements.push(translateNode(element, self, sf));
+			return {
+				...self,
+				elements
+			};
+		}
+		case ts.SyntaxKind.NamespaceImport: {
+			const ns = n;
+			const self = {
+				kind: DomainSyntaxKind.NamespaceImport,
+				pos,
+				end,
+				parent,
+				name: void 0
+			};
+			self.name = translateNode(ns.name, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.ImportSpecifier: {
+			const spec = n;
+			const self = {
+				kind: DomainSyntaxKind.ImportSpecifier,
+				pos,
+				end,
+				parent,
+				propertyName: void 0,
+				name: void 0
+			};
+			if (spec.propertyName) self.propertyName = translateNode(spec.propertyName, self, sf);
+			self.name = translateNode(spec.name, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.CallExpression: {
+			const call = n;
+			const self = {
+				kind: DomainSyntaxKind.CallExpression,
+				pos,
+				end,
+				parent,
+				expression: void 0,
+				arguments: []
+			};
+			self.expression = translateNode(call.expression, self, sf);
+			self.arguments = call.arguments.map((arg) => translateNode(arg, self, sf));
+			return self;
+		}
+		case ts.SyntaxKind.PropertyAccessExpression: {
+			const pa = n;
+			const self = {
+				kind: DomainSyntaxKind.PropertyAccessExpression,
+				pos,
+				end,
+				parent,
+				expression: void 0,
+				name: void 0
+			};
+			self.expression = translateNode(pa.expression, self, sf);
+			self.name = translateNode(pa.name, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.ObjectLiteralExpression: {
+			const obj = n;
+			const self = {
+				kind: DomainSyntaxKind.ObjectLiteralExpression,
+				pos,
+				end,
+				parent,
+				properties: []
+			};
+			const properties = [];
+			for (const prop of obj.properties) properties.push(translateNode(prop, self, sf));
+			return {
+				...self,
+				properties
+			};
+		}
+		case ts.SyntaxKind.PropertyAssignment: {
+			const prop = n;
+			const self = {
+				kind: DomainSyntaxKind.PropertyAssignment,
+				pos,
+				end,
+				parent,
+				name: void 0,
+				initializer: void 0
+			};
+			self.name = translateNode(prop.name, self, sf);
+			self.initializer = translateNode(prop.initializer, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.ArrayLiteralExpression: {
+			const arr = n;
+			const self = {
+				kind: DomainSyntaxKind.ArrayLiteralExpression,
+				pos,
+				end,
+				parent,
+				elements: []
+			};
+			const elements = [];
+			for (const element of arr.elements) elements.push(translateNode(element, self, sf));
+			return {
+				...self,
+				elements
+			};
+		}
+		case ts.SyntaxKind.SpreadElement: {
+			const sp = n;
+			const self = {
+				kind: DomainSyntaxKind.SpreadElement,
+				pos,
+				end,
+				parent,
+				expression: void 0
+			};
+			self.expression = translateNode(sp.expression, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.ParenthesizedExpression: {
+			const pe = n;
+			const self = {
+				kind: DomainSyntaxKind.ParenthesizedExpression,
+				pos,
+				end,
+				parent,
+				expression: void 0
+			};
+			self.expression = translateNode(pe.expression, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.AsExpression: {
+			const ae = n;
+			const self = {
+				kind: DomainSyntaxKind.AsExpression,
+				pos,
+				end,
+				parent,
+				expression: void 0
+			};
+			self.expression = translateNode(ae.expression, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.SatisfiesExpression: {
+			const se = n;
+			const self = {
+				kind: DomainSyntaxKind.SatisfiesExpression,
+				pos,
+				end,
+				parent,
+				expression: void 0
+			};
+			self.expression = translateNode(se.expression, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.NonNullExpression: {
+			const nn = n;
+			const self = {
+				kind: DomainSyntaxKind.NonNullExpression,
+				pos,
+				end,
+				parent,
+				expression: void 0
+			};
+			self.expression = translateNode(nn.expression, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.ConditionalExpression: {
+			const ce = n;
+			const self = {
+				kind: DomainSyntaxKind.ConditionalExpression,
+				pos,
+				end,
+				parent,
+				condition: void 0,
+				whenTrue: void 0,
+				whenFalse: void 0
+			};
+			self.condition = translateNode(ce.condition, self, sf);
+			self.whenTrue = translateNode(ce.whenTrue, self, sf);
+			self.whenFalse = translateNode(ce.whenFalse, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.BinaryExpression: {
+			const be = n;
+			const self = {
+				kind: DomainSyntaxKind.BinaryExpression,
+				pos,
+				end,
+				parent,
+				left: void 0,
+				operator: mapBinaryOperator(be.operatorToken),
+				right: void 0
+			};
+			self.left = translateNode(be.left, self, sf);
+			self.right = translateNode(be.right, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.ExpressionStatement: {
+			const es = n;
+			const self = {
+				kind: DomainSyntaxKind.ExpressionStatement,
+				pos,
+				end,
+				parent,
+				expression: void 0
+			};
+			self.expression = translateNode(es.expression, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.JsxAttribute: {
+			const ja = n;
+			const self = {
+				kind: DomainSyntaxKind.JsxAttribute,
+				pos,
+				end,
+				parent,
+				name: void 0,
+				initializer: void 0
+			};
+			self.name = translateNode(ja.name, self, sf);
+			if (ja.initializer) self.initializer = translateNode(ja.initializer, self, sf);
+			return self;
+		}
+		case ts.SyntaxKind.JsxExpression: {
+			const je = n;
+			const self = {
+				kind: DomainSyntaxKind.JsxExpression,
+				pos,
+				end,
+				parent,
+				expression: void 0
+			};
+			if (je.expression) self.expression = translateNode(je.expression, self, sf);
+			return self;
+		}
+		default: return translateUnknown(n, parent, sf);
+	}
+}
+function translateTypeScriptSourceFile(tsSf) {
+	const text = tsSf.getFullText();
+	const statements = tsSf.statements.map((statement) => translateNode(statement, null, tsSf));
+	return {
+		fileName: tsSf.fileName,
+		text,
+		statements
+	};
+}
+function parseDomainSourceFile(filePath, sourceText) {
+	const scriptKind = filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+	return translateTypeScriptSourceFile(ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, scriptKind));
+}
+//#endregion
+export { parseDomainSourceFile, translateNode, translateTypeScriptSourceFile };

package/dist/lib/arrange/presentation/arrange-cli-schema.presenter.mjs

@@ -0,0 +1,29 @@
+import { z } from "zod";
+//#region src/lib/arrange/presentation/arrange-cli-schema.presenter.ts
+const arrangeAnalyzeDirectoryRequestSchema = z.object({
+	analyzeRootPath: z.string().min(1, "analyzeRootPath is required"),
+	json: z.boolean().optional()
+});
+const arrangeSyncRunRequestSchema = z.object({
+	rootDir: z.string().min(1),
+	targetPath: z.string().min(1),
+	write: z.boolean(),
+	json: z.boolean().optional(),
+	withClassName: z.boolean().optional(),
+	cnImport: z.string().optional(),
+	config: z.unknown().optional()
+});
+const arrangeRunTargetRequestSchema = z.object({
+	targetPath: z.string().min(1),
+	write: z.boolean(),
+	withClassName: z.boolean().optional(),
+	cnImport: z.string().optional()
+});
+const arrangeSuggestGroupsRequestSchema = z.object({
+	inlineClasses: z.string().min(1, "Pass a class string. Example: codefast arrange group \"flex gap-2 text-sm rounded-md\""),
+	emitTvStyleArray: z.boolean(),
+	trailingClassName: z.boolean(),
+	json: z.boolean().optional()
+});
+//#endregion
+export { arrangeAnalyzeDirectoryRequestSchema, arrangeRunTargetRequestSchema, arrangeSuggestGroupsRequestSchema, arrangeSyncRunRequestSchema };

package/dist/lib/arrange/presentation/arrange-sync.presenter.mjs

@@ -0,0 +1,12 @@
+import { exitCodeForArrangeSyncResult } from "../application/arrange-sync-cli-result.mjs";
+//#region src/lib/arrange/presentation/arrange-sync.presenter.ts
+function presentArrangeSyncResult(logger, result, write) {
+	logger.out(`\nTotal: ${result.filePaths.length} file(s), ${result.totalFound} site(s) (cn/tv/JSX className) to review.`);
+	if (write) logger.out(`Applied: ${result.totalChanged} site(s) updated.`);
+	else logger.out(`(Run "apply" to write changes, or "pnpm cli:arrange-apply" / "pnpm exec codefast arrange apply")`);
+	if (write ? result.totalChanged > 0 : result.totalFound > 0) logger.out("Note: class order may change across concern groups — smoke-test the UI if you rely on cascade order.");
+	if (result.hookError !== null) logger.err(result.hookError);
+	return exitCodeForArrangeSyncResult(result);
+}
+//#endregion
+export { presentArrangeSyncResult };

package/dist/lib/arrange/presentation/formatters.presenter.mjs

@@ -0,0 +1,2 @@
+import { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue } from "../domain/source-text-formatters.formatter.mjs";
+export { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue };