@tsrx/prettier-plugin 0.3.104 → 0.3.106

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsrx/prettier-plugin",
-  "version": "0.3.104",
+  "version": "0.3.106",
   "description": "Ripple plugin for Prettier",
   "type": "module",
   "module": "src/index.js",
@@ -27,7 +27,7 @@
     "prettier": "^3.8.4"
   },
   "dependencies": {
-    "@tsrx/core": "0.1.44"
+    "@tsrx/core": "0.1.45"
   },
   "files": [
     "src/"

package/src/index.js

@@ -16,7 +16,7 @@
 
 /** @typedef {Partial<Pick<ParserOptions, 'singleQuote' | 'jsxSingleQuote' | 'semi' | 'trailingComma' | 'useTabs' | 'tabWidth' | 'singleAttributePerLine' | 'bracketSameLine' | 'bracketSpacing' | 'arrowParens' | 'originalText' | 'printWidth'>> & { locStart: (node: AST.NodeWithLocation) => number, locEnd: (node: AST.NodeWithLocation) => number }} RippleFormatOptions */
 
-/** @typedef {{ isInAttribute?: boolean, isInArray?: boolean, allowInlineObject?: boolean, isConditionalTest?: boolean, isNestedConditional?: boolean, suppressLeadingComments?: boolean, suppressExpressionLeadingComments?: boolean, isInlineContext?: boolean, isStatement?: boolean, isLogicalAndOr?: boolean, allowShorthandProperty?: boolean, isFirstChild?: boolean, noBreakInside?: boolean, expandLastArg?: boolean, preferInlineSimpleUnionType?: boolean }} PrintArgs */
+/** @typedef {{ isInAttribute?: boolean, isInArray?: boolean, allowInlineObject?: boolean, isConditionalTest?: boolean, isNestedConditional?: boolean, suppressLeadingComments?: boolean, suppressExpressionLeadingComments?: boolean, suppressOwnParens?: boolean, isInlineContext?: boolean, isStatement?: boolean, isLogicalAndOr?: boolean, allowShorthandProperty?: boolean, isFirstChild?: boolean, noBreakInside?: boolean, expandLastArg?: boolean, preferInlineSimpleUnionType?: boolean }} PrintArgs */
 
 import { parseModule } from '@tsrx/core';
 import { doc } from 'prettier';
@@ -423,6 +423,27 @@ function binaryExpressionNeedsParens(node, parent) {
 	return false;
 }
 
+/**
+ * Check whether the operand of an `as`/`satisfies` cast must stay parenthesized.
+ * The cast binds at relational precedence, so lower-precedence operands parse
+ * differently without their parens: `a ?? b as string` is `a ?? (b as string)`,
+ * and mixing `??` with an unparenthesized cast operand is a TS syntax error.
+ * @param {AST.Node} expression - The cast operand
+ * @returns {boolean} - True if parentheses are required
+ */
+function castOperandNeedsParens(expression) {
+	switch (expression.type) {
+		case 'LogicalExpression':
+		case 'ArrowFunctionExpression':
+		case 'YieldExpression':
+			return true;
+		case 'BinaryExpression':
+			return getPrecedence(expression.operator) < PRECEDENCE['<'];
+		default:
+			return false;
+	}
+}
+
 /**
  * Check if a parenthesized AssignmentExpression needs its parentheses preserved.
  * @param {AST.AssignmentExpression} node - The expression node
@@ -1413,7 +1434,10 @@ function printRippleNode(node, path, options, print, args) {
 				}
 
 				const trailingDoc = shouldUseTrailingComma ? ifBreak(',', '') : '';
-				nodeContent = group(['[', indent([softline, fill(fillParts), trailingDoc]), softline, ']']);
+				// All-or-nothing group instead of fill(): packing several elements
+				// per wrapped line is never a fixpoint — the repacked output reparses
+				// as a multiline array and would then break one element per line.
+				nodeContent = group(['[', indent([softline, fillParts, trailingDoc]), softline, ']']);
 				break;
 			}
 
@@ -1578,7 +1602,7 @@ function printRippleNode(node, path, options, print, args) {
 		}
 
 		case 'MemberExpression':
-			nodeContent = printMemberExpression(node, path, options, print);
+			nodeContent = printMemberExpression(node, path, options, print, args);
 			break;
 
 		case 'MetaProperty':
@@ -1640,7 +1664,7 @@ function printRippleNode(node, path, options, print, args) {
 
 			// Preserve parentheses for type-annotated call expressions
 			// When parenthesized with leading comments, use grouping to allow breaking
-			if (node.metadata?.parenthesized) {
+			if (node.metadata?.parenthesized && !args?.suppressOwnParens) {
 				const hasLeadingComments = node.leadingComments && node.leadingComments.length > 0;
 				if (hasLeadingComments) {
 					// Group with softline to allow breaking after opening paren
@@ -1688,10 +1712,14 @@ function printRippleNode(node, path, options, print, args) {
 				(typePath) => print(typePath, { preferInlineSimpleUnionType: true }),
 				'typeAnnotation',
 			);
+			const expressionDoc = path.call(print, 'expression');
+			const operand = castOperandNeedsParens(node.expression)
+				? ['(', expressionDoc, ')']
+				: expressionDoc;
 			nodeContent =
 				node.typeAnnotation.type !== 'TSTypeLiteral' && willBreak(typeAnnotation)
-					? [path.call(print, 'expression'), ' as', indent([line, typeAnnotation])]
-					: [path.call(print, 'expression'), ' as ', typeAnnotation];
+					? [operand, ' as', indent([line, typeAnnotation])]
+					: [operand, ' as ', typeAnnotation];
 			break;
 		}
 
@@ -1700,10 +1728,14 @@ function printRippleNode(node, path, options, print, args) {
 				(typePath) => print(typePath, { preferInlineSimpleUnionType: true }),
 				'typeAnnotation',
 			);
+			const expressionDoc = path.call(print, 'expression');
+			const operand = castOperandNeedsParens(node.expression)
+				? ['(', expressionDoc, ')']
+				: expressionDoc;
 			nodeContent =
 				node.typeAnnotation.type !== 'TSTypeLiteral' && willBreak(typeAnnotation)
-					? [path.call(print, 'expression'), ' satisfies', indent([line, typeAnnotation])]
-					: [path.call(print, 'expression'), ' satisfies ', typeAnnotation];
+					? [operand, ' satisfies', indent([line, typeAnnotation])]
+					: [operand, ' satisfies ', typeAnnotation];
 			break;
 		}
 
@@ -1892,22 +1924,34 @@ function printRippleNode(node, path, options, print, args) {
 		}
 		case 'Identifier': {
 			// Simple case - just return the name directly like Prettier core
+			const parent = path.getParentNode();
+			// The definite-assignment assertion (`let x!: T`) lives on the declarator
+			const definiteMarker =
+				parent && parent.type === 'VariableDeclarator' && parent.id === node && parent.definite
+					? '!'
+					: '';
 			let identifierContent;
 			if (node.typeAnnotation) {
 				const optionalMarker = node.optional ? '?' : '';
-				identifierContent = [node.name, optionalMarker, ': ', path.call(print, 'typeAnnotation')];
+				identifierContent = [
+					node.name,
+					definiteMarker,
+					optionalMarker,
+					': ',
+					path.call(print, 'typeAnnotation'),
+				];
 			} else {
-				identifierContent = node.name;
+				identifierContent = definiteMarker ? [node.name, definiteMarker] : node.name;
 			}
 			// Preserve parentheses for type-cast identifiers, but only if:
 			// 1. The identifier itself is marked as parenthesized
 			// 2. The parent is NOT handling parentheses itself (MemberExpression, AssignmentExpression, etc.)
-			const parent = path.getParentNode();
 			const parentHandlesParens =
 				parent &&
 				(parent.type === 'MemberExpression' ||
 					(parent.type === 'AssignmentExpression' && parent.left === node));
-			const shouldAddParens = node.metadata?.parenthesized && !parentHandlesParens;
+			const shouldAddParens =
+				node.metadata?.parenthesized && !parentHandlesParens && !args?.suppressOwnParens;
 			if (shouldAddParens) {
 				nodeContent = ['(', identifierContent, ')'];
 			} else {
@@ -2068,8 +2112,26 @@ function printRippleNode(node, path, options, print, args) {
 			/** @type {Doc[]} */
 			const parts = ['return'];
 			if (node.argument) {
-				parts.push(' ');
-				parts.push(path.call(print, 'argument'));
+				if (argumentHasOwnLineLeadingComment(node.argument)) {
+					// The comment prints on its own line, which would separate `return`
+					// from its argument and trigger ASI — keep the argument in parens.
+					// These parens replace any the argument would print for itself.
+					parts.push(
+						' (',
+						indent([
+							hardline,
+							path.call(
+								(argumentPath) => print(argumentPath, { suppressOwnParens: true }),
+								'argument',
+							),
+						]),
+						hardline,
+						')',
+					);
+				} else {
+					parts.push(' ');
+					parts.push(path.call(print, 'argument'));
+				}
 			}
 			parts.push(semi(options));
 			nodeContent = parts;
@@ -2247,7 +2309,7 @@ function printRippleNode(node, path, options, print, args) {
 			}
 
 			// Wrap in parentheses if metadata indicates they were present
-			if (node.metadata?.parenthesized) {
+			if (node.metadata?.parenthesized && !args?.suppressOwnParens) {
 				result = ['(', result, ')'];
 			}
 
@@ -2271,7 +2333,7 @@ function printRippleNode(node, path, options, print, args) {
 		}
 
 		case 'MemberExpression':
-			nodeContent = printMemberExpression(node, path, options, print);
+			nodeContent = printMemberExpression(node, path, options, print, args);
 			break;
 
 		case 'ObjectPattern':
@@ -2737,12 +2799,8 @@ function printFunctionExpression(node, path, options, print) {
 		parts.push(' ');
 	}
 
-	// Print parameters using shared function
-	const paramsPart = printFunctionParameters(path, options, print);
-	parts.push(group(paramsPart)); // Handle return type annotation
-	if (node.returnType) {
-		parts.push(': ', path.call(print, 'returnType'));
-	}
+	// Print parameters and return type as a single group
+	parts.push(printFunctionSignature(node, path, options, print));
 
 	parts.push(' ');
 	parts.push(path.call(print, 'body'));
@@ -2790,12 +2848,8 @@ function printArrowFunction(node, path, options, print, args) {
 	) {
 		parts.push(path.call(print, 'params', 0));
 	} else {
-		// Print parameters using shared function
-		const paramsPart = printFunctionParameters(path, options, print);
-		parts.push(group(paramsPart));
-	} // Handle return type annotation
-	if (node.returnType) {
-		parts.push(': ', path.call(print, 'returnType'));
+		// Print parameters and return type as a single group
+		parts.push(printFunctionSignature(node, path, options, print));
 	}
 
 	// For block statements, print the body directly to get proper formatting
@@ -2808,7 +2862,6 @@ function printArrowFunction(node, path, options, print, args) {
 		// to avoid ambiguity with block statements or to clarify intent
 		const bodyDoc = path.call(print, 'body');
 		const groupId = Symbol('arrow');
-		const shouldBreakBody = shouldBreakArrowExpressionBody(node.body, options, args);
 		/** @type {Doc | Doc[]} */
 		let bodyContent;
 		if (
@@ -2820,21 +2873,26 @@ function printArrowFunction(node, path, options, print, args) {
 		} else {
 			bodyContent = bodyDoc;
 		}
-		if (shouldBreakBody) {
-			parts.push(' =>', indent([hardline, bodyContent]));
-		} else {
-			if (isTemplateExpression(node.body)) {
-				return conditionalGroup([
-					group([...parts, ' => ', bodyContent]),
-					group([...parts, ' =>', indent([hardline, bodyContent])]),
-				]);
-			}
-			parts.push(
-				' =>',
-				group(indent(line), { id: groupId }),
-				indentIfBreak(bodyContent, { groupId }),
-			);
+		if (isTemplateExpression(node.body)) {
+			return conditionalGroup([
+				group([...parts, ' => ', bodyContent]),
+				group([...parts, ' =>', indent([hardline, bodyContent])]),
+			]);
 		}
+		if (node.body.type === 'BinaryExpression' || node.body.type === 'LogicalExpression') {
+			// Keep the body inline when it fits; otherwise break right after `=>`
+			// so the body starts on its own line. An inner group scoped to the body
+			// makes that call from the printed doc (not the original source span,
+			// which kept the two passes disagreeing) and still works when the
+			// parameter list itself breaks.
+			parts.push(' =>', group(indent([line, bodyContent])));
+			return group(parts);
+		}
+		parts.push(
+			' =>',
+			group(indent(line), { id: groupId }),
+			indentIfBreak(bodyContent, { groupId }),
+		);
 	}
 
 	return group(parts);
@@ -2849,25 +2907,6 @@ function isTemplateExpression(node) {
 	return node.type === 'JSXElement' || node.type === 'JSXFragment';
 }
 
-/**
- * Check whether a braced attribute expression should close on its own line.
- * @param {AST.Node} node - The expression inside the attribute braces
- * @param {RippleFormatOptions} options
- * @param {AST.Node} [attributeNode]
- * @returns {boolean}
- */
-function shouldBreakAttributeExpressionClosingBrace(node, options, attributeNode = node) {
-	return (
-		node.type === 'ArrowFunctionExpression' &&
-		node.body &&
-		isTemplateExpression(node.body) &&
-		sourceSpanExceedsPrintWidth(
-			/** @type {AST.NodeWithLocation} */ (/** @type {unknown} */ (attributeNode ?? node)),
-			options,
-		)
-	);
-}
-
 /**
  * Print an export default declaration
  * @param {AST.ExportDefaultDeclaration} node - The export default node
@@ -2904,10 +2943,50 @@ function shouldHugTheOnlyFunctionParameter(node) {
 			parameter.type === 'ArrayPattern' ||
 			(parameter.type === 'Identifier' &&
 				!!parameter.typeAnnotation &&
-				parameter.typeAnnotation.type === 'TSTypeAnnotation'))
+				parameter.typeAnnotation.type === 'TSTypeAnnotation' &&
+				isHuggableParameterType(parameter.typeAnnotation.typeAnnotation)))
 	);
 }
 
+/**
+ * Check if a type node is an object-like type (object literal or mapped type)
+ * @param {AST.Node | undefined} node - The type node
+ * @returns {boolean}
+ */
+function isObjectType(node) {
+	return !!node && (node.type === 'TSTypeLiteral' || node.type === 'TSMappedType');
+}
+
+/**
+ * Check if a parameter's type annotation should keep the parameter hugged.
+ * Object-like types hug like vanilla prettier; additionally a type reference
+ * wrapping a single object type (`props: Props<{ ... }>`) hugs, since that is
+ * the common TSRX component-props shape. Other references, like a plain
+ * `initialState: State`, leave the parameter list free to break.
+ * @param {AST.Node | undefined} node - The type node
+ * @returns {boolean}
+ */
+function isHuggableParameterType(node) {
+	if (isObjectType(node)) {
+		return true;
+	}
+	if (node?.type === 'TSIntersectionType') {
+		const types = /** @type {AST.TSIntersectionType} */ (node).types;
+		return types?.length > 0 && isHuggableParameterType(types[types.length - 1]);
+	}
+	if (node?.type === 'TSTypeReference') {
+		const typeArguments =
+			/** @type {AST.TSTypeReference & { typeParameters?: AST.TSTypeParameterInstantiation }} */ (
+				node
+			).typeArguments ??
+			/** @type {AST.TSTypeReference & { typeParameters?: AST.TSTypeParameterInstantiation }} */ (
+				node
+			).typeParameters;
+		return typeArguments?.params?.length === 1 && isObjectType(typeArguments.params[0]);
+	}
+	return false;
+}
+
 /**
  * Print function parameters with proper formatting
  * @param {AstPath<AST.FunctionExpression | AST.ArrowFunctionExpression | AST.TSDeclareFunction | AST.FunctionDeclaration>} path - The function path
@@ -2963,6 +3042,56 @@ function printFunctionParameters(path, options, print) {
 	];
 }
 
+/**
+ * Check whether the parameter list should be grouped separately from the return
+ * type, so a breaking return type does not force the parameters to break too.
+ * @param {AST.FunctionExpression | AST.ArrowFunctionExpression | AST.TSDeclareFunction | AST.FunctionDeclaration} functionNode - The function node
+ * @param {Doc} returnTypeDoc - The printed return type
+ * @returns {boolean}
+ */
+function shouldGroupFunctionParameters(functionNode, returnTypeDoc) {
+	const returnTypeNode = functionNode.returnType?.typeAnnotation;
+	const typeParameters = functionNode.typeParameters?.params;
+	if (typeParameters) {
+		if (typeParameters.length > 1) {
+			return false;
+		}
+		if (typeParameters.length === 1) {
+			const typeParameter = typeParameters[0];
+			if (typeParameter.constraint || typeParameter.default) {
+				return false;
+			}
+		}
+	}
+	return (
+		getFunctionParameters(functionNode).length === 1 &&
+		(isObjectType(returnTypeNode) || willBreak(returnTypeDoc))
+	);
+}
+
+/**
+ * Print function parameters together with the return type as a single group, so
+ * the fitter breaks the parameter list before type arguments nested in the
+ * return type, matching vanilla prettier's signature layout.
+ * @param {AST.FunctionExpression | AST.ArrowFunctionExpression | AST.TSDeclareFunction | AST.FunctionDeclaration} node - The function node
+ * @param {AstPath<AST.FunctionExpression | AST.ArrowFunctionExpression | AST.TSDeclareFunction | AST.FunctionDeclaration>} path - The function path
+ * @param {RippleFormatOptions} options - Prettier options
+ * @param {PrintFn} print - Print callback
+ * @returns {Doc}
+ */
+function printFunctionSignature(node, path, options, print) {
+	const paramsPart = printFunctionParameters(path, options, print);
+	if (!node.returnType) {
+		return group(paramsPart);
+	}
+	/** @type {Doc[]} */
+	const returnTypeDoc = [': ', path.call(print, 'returnType')];
+	if (shouldGroupFunctionParameters(node, returnTypeDoc)) {
+		return group([group(paramsPart), ...returnTypeDoc]);
+	}
+	return group([...paramsPart, ...returnTypeDoc]);
+}
+
 /**
  * Check if a node is spread-like (SpreadElement or RestElement)
  * @param {AST.Node} node - The AST node
@@ -3060,34 +3189,6 @@ function shouldHugArrowFunctions(args) {
 	return firstBlockIndex === 0;
 }
 
-/**
- * Check whether a node's original source span exceeds the configured print width.
- * @param {AST.NodeWithLocation} node - The node to check
- * @param {RippleFormatOptions} options - Prettier options
- * @returns {boolean}
- */
-function sourceSpanExceedsPrintWidth(node, options) {
-	const printWidth = options.printWidth ?? 80;
-	if (!options.originalText || node.start === undefined || node.end === undefined) {
-		return false;
-	}
-	return options.originalText.slice(node.start, node.end).length > printWidth;
-}
-
-/**
- * Check if an arrow expression body should break immediately after `=>`.
- * @param {AST.Expression} node - The arrow body expression
- * @param {RippleFormatOptions} options - Prettier options
- * @param {PrintArgs} [args] - Additional context arguments
- * @returns {boolean}
- */
-function shouldBreakArrowExpressionBody(node, options, args) {
-	return (
-		(node.type === 'BinaryExpression' || node.type === 'LogicalExpression') &&
-		sourceSpanExceedsPrintWidth(/** @type {AST.NodeWithLocation} */ (node), options)
-	);
-}
-
 /**
  * Print call expression arguments
  * @param {AstPath<AST.CallExpression>} path - The call path
@@ -3337,14 +3438,8 @@ function printTSDeclareFunction(node, path, options, print) {
 		}
 	}
 
-	// Print parameters using shared function
-	const paramsPart = printFunctionParameters(path, options, print);
-	parts.push(group(paramsPart));
-
-	// Handle return type annotation
-	if (node.returnType) {
-		parts.push(': ', path.call(print, 'returnType'));
-	}
+	// Print parameters and return type as a single group
+	parts.push(printFunctionSignature(node, path, options, print));
 
 	// TSDeclareFunction ends with semicolon, no body
 	parts.push(';');
@@ -3389,14 +3484,8 @@ function printFunctionDeclaration(node, path, options, print) {
 		}
 	}
 
-	// Print parameters using shared function
-	const paramsPart = printFunctionParameters(path, options, print);
-	parts.push(group(paramsPart));
-
-	// Handle return type annotation
-	if (node.returnType) {
-		parts.push(': ', path.call(print, 'returnType'));
-	}
+	// Print parameters and return type as a single group
+	parts.push(printFunctionSignature(node, path, options, print));
 
 	parts.push(' ');
 	parts.push(path.call(print, 'body'));
@@ -4119,9 +4208,10 @@ function printMethodDefinition(node, path, options, print) {
  * @param {AstPath<AST.MemberExpression>} path - The AST path
  * @param {RippleFormatOptions} options - Prettier options
  * @param {PrintFn} print - Print callback
+ * @param {PrintArgs} [args] - Additional context arguments
  * @returns {Doc}
  */
-function printMemberExpression(node, path, options, print) {
+function printMemberExpression(node, path, options, print, args) {
 	let objectPart = path.call(print, 'object');
 	// Preserve parentheses around the object when present
 	if (node.object.metadata?.parenthesized) {
@@ -4139,7 +4229,7 @@ function printMemberExpression(node, path, options, print) {
 	}
 
 	// Preserve parentheses around the entire member expression when present
-	if (node.metadata?.parenthesized) {
+	if (node.metadata?.parenthesized && !args?.suppressOwnParens) {
 		// Check if there are leading comments - if so, use group with softlines to allow breaking
 		const hasLeadingComments = node.leadingComments && node.leadingComments.length > 0;
 		if (hasLeadingComments) {
@@ -4323,12 +4413,50 @@ function printTaggedTemplateExpression(node, path, options, print) {
 function printThrowStatement(node, path, options, print) {
 	/** @type {Doc[]} */
 	const parts = [];
-	parts.push('throw ');
-	parts.push(path.call(print, 'argument'));
+	if (argumentHasOwnLineLeadingComment(node.argument)) {
+		// Same ASI hazard as `return`: keep the argument attached via parens.
+		// These parens replace any the argument would print for itself.
+		parts.push(
+			'throw (',
+			indent([
+				hardline,
+				path.call((argumentPath) => print(argumentPath, { suppressOwnParens: true }), 'argument'),
+			]),
+			hardline,
+			')',
+		);
+	} else {
+		parts.push('throw ');
+		parts.push(path.call(print, 'argument'));
+	}
 	parts.push(semi(options));
 	return parts;
 }
 
+/**
+ * Check whether a return/throw argument has a leading comment that prints on
+ * its own line (line comments always do; block comments only when they did not
+ * share a line with the argument in the source).
+ * @param {AST.Node | null | undefined} argument - The statement argument
+ * @returns {boolean}
+ */
+function argumentHasOwnLineLeadingComment(argument) {
+	if (!argument) {
+		return false;
+	}
+	const comments = /** @type {AST.NodeWithMaybeComments} */ (argument).leadingComments;
+	if (!comments) {
+		return false;
+	}
+	return comments.some(
+		(comment) =>
+			comment.type === 'Line' ||
+			!comment.loc ||
+			!argument.loc ||
+			comment.loc.end.line !== argument.loc.start.line,
+	);
+}
+
 /**
  * Print a TypeScript interface declaration
  * @param {AST.TSInterfaceDeclaration} node - The interface declaration node
@@ -4524,19 +4652,28 @@ function printTSTypeParameterDeclaration(node, path, options, print) {
 	if (!node.params || node.params.length === 0) {
 		return '';
 	}
-	/** @type {Doc[]} */
-	const parts = [];
-	parts.push('<');
 	const paramList = path.map(print, 'params');
-	for (let i = 0; i < paramList.length; i++) {
-		if (i > 0) parts.push(', ');
-		parts.push(paramList[i]);
-	}
-	if (node.params.length === 1 && node.extra?.trailingComma !== undefined) {
-		parts.push(',');
+
+	// In JSX-shaped files a lone `<T>` on an arrow function is ambiguous with a JSX
+	// element, so a source-level trailing comma (`<T,>`) is syntactically meaningful
+	// there. Keep single-param arrow generics flat and preserve that comma; breaking
+	// them would add a trailing comma that flattens back on the next pass.
+	const parent = /** @type {AST.Node | null} */ (path.getParentNode());
+	if (parent?.type === 'ArrowFunctionExpression' && node.params.length === 1) {
+		const trailing = node.extra?.trailingComma !== undefined ? ',' : '';
+		return ['<', paramList[0], trailing, '>'];
 	}
-	parts.push('>');
-	return parts;
+
+	return group([
+		'<',
+		indent([
+			softline,
+			join([',', line], paramList),
+			ifBreak(shouldPrintComma(options, 'all') ? ',' : ''),
+		]),
+		softline,
+		'>',
+	]);
 }
 
 /**
@@ -4580,18 +4717,18 @@ function printTSTypeParameterInstantiation(node, path, options, print) {
 
 	const paramList = path.map(print, 'params');
 
+	// Hug a lone object-type argument against the brackets: Foo<{ ... }>
+	if (
+		node.params.length === 1 &&
+		isObjectType(node.params[0]) &&
+		!hasComment(/** @type {AST.Node & AST.NodeWithMaybeComments} */ (node.params[0]))
+	) {
+		return ['<', paramList[0], '>'];
+	}
+
 	// Check if any param has line breaks (e.g., contains object types)
 	const hasBreakingParam = paramList.some((param) => willBreak(param));
 
-	// Build inline version: <T, U>
-	/** @type {Doc[]} */
-	const inlineParts = ['<'];
-	for (let i = 0; i < paramList.length; i++) {
-		if (i > 0) inlineParts.push(', ');
-		inlineParts.push(paramList[i]);
-	}
-	inlineParts.push('>');
-
 	// If any param breaks, use the breaking version with proper indentation
 	if (hasBreakingParam) {
 		// Build breaking version: <\n  T,\n  U\n>
@@ -5349,9 +5486,16 @@ function printTSTypeLiteral(node, path, options, print) {
 		'}',
 	]);
 
-	return conditionalGroup(
-		wasOriginallySingleLine(node) ? [inlineDoc, multilineDoc] : [multilineDoc, inlineDoc],
-	);
+	if (!wasOriginallySingleLine(node)) {
+		// A hardline-first conditionalGroup always picks that state (fits()
+		// short-circuits to true on hardlines) while hiding the hardlines from
+		// enclosing groups' break propagation — ancestors then stay flat and
+		// print following siblings past printWidth. The multiline doc alone is
+		// equivalent and propagates its breaks correctly.
+		return multilineDoc;
+	}
+
+	return conditionalGroup([inlineDoc, multilineDoc]);
 }
 
 /**
@@ -5520,26 +5664,16 @@ function printTSTypeReference(node, path, options, print) {
 	/** @type {Doc[]} */
 	const parts = [path.call(print, 'typeName')];
 
-	// Handle both typeArguments and typeParameters (different AST variations)
+	// Handle both typeArguments and typeParameters (different AST variations).
+	// Both are TSTypeParameterInstantiation nodes, whose printer can break the
+	// argument list when it does not fit.
 	if (node.typeArguments) {
-		parts.push('<');
-		const typeArgs = path.map(print, 'typeArguments', 'params');
-		for (let i = 0; i < typeArgs.length; i++) {
-			if (i > 0) parts.push(', ');
-			parts.push(typeArgs[i]);
-		}
-		parts.push('>');
+		parts.push(path.call(print, 'typeArguments'));
 		// @ts-expect-error - acorn-typescript uses typeParameters instead of typeArguments
 		// we normalize it in the analyze phase, but here we get the parser ast
 	} else if (node.typeParameters) {
-		parts.push('<');
 		// @ts-expect-error - acorn-typescript uses typeParameters instead of typeArguments
-		const typeParams = path.map(print, 'typeParameters', 'params');
-		for (let i = 0; i < typeParams.length; i++) {
-			if (i > 0) parts.push(', ');
-			parts.push(typeParams[i]);
-		}
-		parts.push('>');
+		parts.push(path.call(print, 'typeParameters'));
 	}
 
 	return parts;
@@ -5829,7 +5963,9 @@ function isSimpleJSXExpressionChild(child) {
 		expression?.type === 'MemberExpression' ||
 		expression?.type === 'CallExpression' ||
 		expression?.type === 'BinaryExpression' ||
-		expression?.type === 'LogicalExpression'
+		expression?.type === 'LogicalExpression' ||
+		// Text holes like `{expr as string}` are as simple as their operand
+		expression?.type === 'TSAsExpression'
 	);
 }
 
@@ -6548,9 +6684,6 @@ function printJSXAttribute(attr, path, options, print) {
 			'value',
 			'expression',
 		);
-		if (shouldBreakAttributeExpressionClosingBrace(expression, options, attr)) {
-			return [name, '={', exprDoc, hardline, '}'];
-		}
 		return [name, '={', exprDoc, '}'];
 	}
 

package/src/index.test.js

@@ -55,15 +55,23 @@ describe('prettier-plugin', () => {
 	});
 
 	/**
+	 * Format tsrx source. Every call also verifies the output is a fixpoint:
+	 * formatting must be single-pass idempotent (a second pass may not change
+	 * a single byte), so the whole suite doubles as an idempotence corpus.
 	 * @param {string} code
 	 * @param {import('prettier').Options} [options]
 	 */
 	const format = async (code, options = {}) => {
-		return await prettier.format(code, {
+		/** @type {import('prettier').Options} */
+		const resolvedOptions = {
 			parser: 'tsrx',
 			plugins: [join(__dirname, 'index.js')],
 			...options,
-		});
+		};
+		const once = await prettier.format(code, resolvedOptions);
+		const twice = await prettier.format(once, resolvedOptions);
+		expect(twice, 'formatting must be idempotent (second pass changed the output)').toBe(once);
+		return once;
 	};
 
 	it('formats functions that return native elements', async () => {
@@ -888,8 +896,7 @@ const items=[1,2,3];
   <List
     items={props.items}
     renderItem={(item) =>
-      <><ItemView {item} onSelect={props.onSelect} /></>
-    }
+      <><ItemView {item} onSelect={props.onSelect} /></>}
   />
 }`;
 		const result = await format(input, { singleQuote: true, printWidth: 60 });
@@ -1243,7 +1250,8 @@ const items=[1,2,3];
 		it('should format destructured dynamic import() in Promise.all', async () => {
 			const input = `const [{ EditorState }, { oneDark }] = await Promise.all([import('@codemirror/state'), import('@codemirror/theme-one-dark')]);`;
 			const expected = `const [{ EditorState }, { oneDark }] = await Promise.all([
-  import("@codemirror/state"), import("@codemirror/theme-one-dark"),
+  import("@codemirror/state"),
+  import("@codemirror/theme-one-dark"),
 ]);`;
 			const result = await format(input);
 			expect(result).toBeWithNewline(expected);
@@ -3377,7 +3385,8 @@ function test() {
 
 			const expected = `const arr = [
   1, /* comment 1 */
-  2, 3,
+  2,
+  3,
   // comment 2
 ];`;
 
@@ -3763,6 +3772,45 @@ const deleteButton = container.querySelector(
 			expect(result).toBeWithNewline(expected);
 		});
 
+		it('should keep comments attached to their type arguments and stay idempotent', async () => {
+			const input = `interface Props {
+	form: AppFieldExtendedReactFormApi<
+		unknown,
+		| undefined
+		| FormAsyncValidateOrFn<unknown>, // this types it as 'never' in the render prop. It should prevent any
+		// untyped meta passed to the handleSubmit by accident.
+		NoInfer<TSubmitMeta>
+	>;
+}`;
+			// Matches vanilla prettier's typescript parser output for the same input.
+			const expected = `interface Props {
+	form: AppFieldExtendedReactFormApi<
+		unknown,
+		undefined | FormAsyncValidateOrFn<unknown>, // this types it as 'never' in the render prop. It should prevent any
+		// untyped meta passed to the handleSubmit by accident.
+		NoInfer<TSubmitMeta>
+	>;
+}`;
+			const options = { useTabs: true, tabWidth: 2, singleQuote: true, printWidth: 100 };
+			const result = await format(input, options);
+			expect(result).toBeWithNewline(expected);
+			expect(await format(result, options)).toBe(result);
+		});
+
+		it('should hug a lone object type argument against the angle brackets', async () => {
+			const input = `function Button(props: PropsWithExtras<{
+	variant: string;
+	label: string;
+	onClick: EventListener;
+}>) @{
+	<button class={props.variant} onClick={props.onClick}>{props.label}</button>
+}`;
+			const options = { useTabs: true, tabWidth: 2, singleQuote: true, printWidth: 100 };
+			const result = await format(input, options);
+			expect(result).toBeWithNewline(input);
+			expect(await format(result, options)).toBe(result);
+		});
+
 		it('should not overindent multiline object type aliases', async () => {
 			const input = `type ModuleShape = {
   default: ComponentType<{ value: string }>;
@@ -6493,4 +6541,297 @@ function RowList({ rows, Row }) {
 			expect(result).toBeWithNewline(expected);
 		});
 	});
+
+	describe('parens around as-cast operands', () => {
+		it('keeps parens around a nullish coalescing operand of an as-cast', async () => {
+			const input = `function App() {
+  return <span>{(activeAuthor ?? "All authors") as string}</span>;
+}`;
+
+			const result = await format(input);
+			expect(result).toBeWithNewline(input);
+		});
+
+		it('keeps parens around logical and equality operands of as-casts', async () => {
+			const input = `function App() {
+  const a = (x || y) as string;
+  const b = (x == y) as boolean;
+  const c = (x ?? y) satisfies string;
+  return <div>{a}</div>;
+}`;
+
+			const result = await format(input);
+			expect(result).toBeWithNewline(input);
+		});
+
+		it('does not add parens around higher-precedence operands of as-casts', async () => {
+			const input = `function App() {
+  const a = x + y as string;
+  const b = x < y as unknown;
+  return <div>{a}</div>;
+}`;
+
+			const result = await format(input);
+			expect(result).toBeWithNewline(input);
+		});
+	});
+
+	describe('definite assignment assertions', () => {
+		it('keeps the definite assignment assertion on variable declarations', async () => {
+			const input = `function App() {
+  let cleanup!: () => void;
+  var count!: number;
+  return <div />;
+}`;
+
+			const result = await format(input);
+			expect(result).toBeWithNewline(input);
+		});
+	});
+
+	describe('idempotence', () => {
+		/**
+		 * @param {string} code
+		 * @param {import('prettier').Options} [options]
+		 */
+		const expectStable = async (code, options = {}) => {
+			const once = await format(code, options);
+			const twice = await format(once, options);
+			expect(twice).toBe(once);
+			return once;
+		};
+
+		it('keeps a return argument with leading line comments after the return keyword', async () => {
+			const input = `function isXOrYInValid(xOrY: string | number | undefined) {
+	return (
+		// number that is not NaN or Infinity
+		(typeof xOrY === 'number' && Number.isFinite(xOrY)) ||
+		// for percentage
+		typeof xOrY === 'string'
+	);
+}`;
+
+			const once = await expectStable(input, {
+				useTabs: true,
+				singleQuote: true,
+				printWidth: 100,
+			});
+			// The argument must stay attached to the return; printing the comment
+			// between `return` and the expression triggers ASI and returns undefined.
+			expect(once).not.toMatch(/return[;\s]*\/\//);
+		});
+
+		it('does not double-wrap self-parenthesizing return and throw arguments', async () => {
+			const input = `function f() {
+  return (
+    // pick the fallback
+    cond ? a : b
+  );
+}
+
+function g() {
+  throw (
+    // wrap the cause
+    makeError(cause)
+  );
+}`;
+
+			const result = await format(input);
+			expect(result).toBeWithNewline(input);
+		});
+
+		it('breaks long logical arrow bodies after multiline type-literal params', async () => {
+			const input = `function f() {
+	const mapping = result.mappings.find(
+		(mapping: {
+			sourceOffsets: number[];
+			generatedOffsets: number[];
+		}) =>
+			mapping.sourceOffsets[0] === source_offset &&
+				mapping.generatedOffsets[0] === generated_offset &&
+				mapping.lengths[0] === identifier.length,
+	);
+}`;
+
+			// The multiline param type used to hide its hardlines from enclosing
+			// groups (fits() short-circuits on hardlines inside conditionalGroup
+			// states), so the body printed flat past printWidth.
+			const result = await format(input, {
+				useTabs: true,
+				singleQuote: true,
+				printWidth: 100,
+			});
+			expect(result).toBeWithNewline(input);
+		});
+
+		it('stabilizes long arrow bodies with logical expressions in one pass', async () => {
+			const input = `function useStack() {
+	return horizontal
+		? {
+				defined: (d: AreaStackDatum<XScale, YScale>) =>
+					isValidNumber(yScale(getStackValue(d.data))) && isValidNumber(xScale(getSecondItem(d))),
+			}
+		: null;
+}`;
+
+			await expectStable(input, {
+				useTabs: true,
+				singleQuote: true,
+				printWidth: 100,
+			});
+		});
+
+		it('stabilizes deeply nested JSX attribute arrows returning JSX in one pass', async () => {
+			const input = `function Parent() {
+	return <div>
+		<section>
+			<article>
+				<fieldset>
+					<group.Subscribe
+						children={(state) => (
+							<span data-testid="state-lastName">{state.values.lastName}</span>
+						)}
+					/>
+				</fieldset>
+			</article>
+		</section>
+	</div>;
+}`;
+
+			await expectStable(input, {
+				useTabs: true,
+				singleQuote: true,
+				printWidth: 100,
+			});
+		});
+	});
+
+	describe('type parameter declarations', () => {
+		/**
+		 * Formats twice and asserts the output is stable (idempotent).
+		 * @param {string} code
+		 * @param {import('prettier').Options} [options]
+		 */
+		const formatStable = async (code, options = {}) => {
+			const once = await format(code, options);
+			const twice = await format(once, options);
+			expect(twice).toBe(once);
+			return once;
+		};
+
+		it('breaks long interface type parameter lists one per line with a trailing comma', async () => {
+			const input = `export interface WithFieldGroupProps<TFieldGroupData, TFieldComponents extends Record<string, HookComponentType<any>>, TFormComponents extends Record<string, HookComponentType<any>>, TSubmitMeta, TRenderProps extends object = Record<string, never>> extends BaseFormOptions<TFieldGroupData, TSubmitMeta> {
+	props?: TRenderProps;
+}`;
+			const expected = `export interface WithFieldGroupProps<
+	TFieldGroupData,
+	TFieldComponents extends Record<string, HookComponentType<any>>,
+	TFormComponents extends Record<string, HookComponentType<any>>,
+	TSubmitMeta,
+	TRenderProps extends object = Record<string, never>,
+> extends BaseFormOptions<TFieldGroupData, TSubmitMeta> {
+	props?: TRenderProps;
+}`;
+
+			const result = await formatStable(input, {
+				printWidth: 100,
+				useTabs: true,
+				singleQuote: true,
+			});
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('prefers breaking the function parameter list over the type parameter list', async () => {
+			const input = `export default function useStateWithCallback<State>(initialState: State): [State, SetStateWithCallback<State>] {
+	return null;
+}`;
+			const expected = `export default function useStateWithCallback<State>(
+	initialState: State,
+): [State, SetStateWithCallback<State>] {
+	return null;
+}`;
+
+			const result = await formatStable(input, {
+				printWidth: 100,
+				useTabs: true,
+				singleQuote: true,
+			});
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('breaks function type parameter lists that overflow on their own', async () => {
+			const input = `function useAppForm<TFormData, TOnMount extends undefined | FormValidateOrFn<TFormData>, TOnChange extends undefined | FormValidateOrFn<TFormData>, TSubmitMeta>(props: FormOptions<TFormData, TOnMount, TOnChange, TSubmitMeta>): void {
+	return;
+}`;
+			const expected = `function useAppForm<
+	TFormData,
+	TOnMount extends undefined | FormValidateOrFn<TFormData>,
+	TOnChange extends undefined | FormValidateOrFn<TFormData>,
+	TSubmitMeta,
+>(props: FormOptions<TFormData, TOnMount, TOnChange, TSubmitMeta>): void {
+	return;
+}`;
+
+			const result = await formatStable(input, {
+				printWidth: 100,
+				useTabs: true,
+				singleQuote: true,
+			});
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('stays idempotent when a single type parameter has to break', async () => {
+			const input = `interface Container<TExtremelyLongParameterName extends Record<string, unknown>> {
+	value: TExtremelyLongParameterName;
+}`;
+			const expected = `interface Container<
+  TExtremelyLongParameterName extends Record<string, unknown>,
+> {
+  value: TExtremelyLongParameterName;
+}`;
+
+			const result = await formatStable(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('preserves the trailing comma of single-param arrow function generics', async () => {
+			const expected = `const identity = <T,>(value: T): T => value;`;
+
+			const result = await formatStable(expected);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('keeps single-param arrow function generics without a trailing comma as-is', async () => {
+			const expected = `const identity = <T>(value: T): T => value;`;
+
+			const result = await formatStable(expected);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('drops meaningless trailing commas from non-arrow type parameter lists', async () => {
+			const input = `function pick<State,>(value: State): State {
+	return value;
+}`;
+			const expected = `function pick<State>(value: State): State {
+  return value;
+}`;
+
+			const result = await formatStable(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('omits the trailing comma in broken type parameter lists when trailingComma is none', async () => {
+			const input = `interface Container<TExtremelyLongParameterName extends Record<string, unknown>> {
+	value: TExtremelyLongParameterName;
+}`;
+			const expected = `interface Container<
+  TExtremelyLongParameterName extends Record<string, unknown>
+> {
+  value: TExtremelyLongParameterName;
+}`;
+
+			const result = await formatStable(input, { trailingComma: 'none' });
+			expect(result).toBeWithNewline(expected);
+		});
+	});
 });