@tsrx/prettier-plugin 0.3.61 → 0.3.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsrx/prettier-plugin",
-  "version": "0.3.61",
+  "version": "0.3.63",
   "description": "Ripple plugin for Prettier",
   "type": "module",
   "module": "src/index.js",
@@ -27,7 +27,7 @@
     "prettier": "^3.8.3"
   },
   "dependencies": {
-    "@tsrx/core": "0.1.11"
+    "@tsrx/core": "0.1.12"
   },
   "files": [
     "src/"

package/src/index.js

@@ -360,6 +360,49 @@ function binaryExpressionNeedsParens(node, parent) {
 	return false;
 }
 
+/**
+ * Check if a parenthesized AssignmentExpression needs its parentheses preserved.
+ * @param {AST.AssignmentExpression} node - The expression node
+ * @param {AST.Node | null} parent - The parent node
+ * @returns {boolean} - True if parentheses are needed
+ */
+function assignmentExpressionNeedsParens(node, parent) {
+	if (!node.metadata?.parenthesized || !parent) {
+		return false;
+	}
+
+	if (parent.type === 'BinaryExpression' || parent.type === 'LogicalExpression') {
+		return true;
+	}
+
+	if (parent.type === 'ConditionalExpression') {
+		return parent.test === node;
+	}
+
+	if (parent.type === 'AwaitExpression' || parent.type === 'YieldExpression') {
+		return parent.argument === node;
+	}
+
+	if (parent.type === 'CallExpression' || parent.type === 'NewExpression') {
+		return parent.callee === node;
+	}
+
+	if (parent.type === 'TaggedTemplateExpression') {
+		return parent.tag === node;
+	}
+
+	if (
+		parent.type === 'TSAsExpression' ||
+		parent.type === 'TSSatisfiesExpression' ||
+		parent.type === 'TSNonNullExpression' ||
+		parent.type === 'TSInstantiationExpression'
+	) {
+		return parent.expression === node;
+	}
+
+	return false;
+}
+
 /**
  * Create a function that skips specified characters in text
  * @param {string | RegExp} characters - Characters to skip
@@ -718,11 +761,13 @@ function printRippleNode(node, path, options, print, args) {
 	const isInlineContext = args && args.isInlineContext;
 	const suppressLeadingComments = args && args.suppressLeadingComments;
 	const suppressExpressionLeadingComments = args && args.suppressExpressionLeadingComments;
+	const parentNode = /** @type {AST.Node | null} */ (path.getParentNode());
 
 	// For TSRXExpression, Text, and Html nodes, don't add leading comments here - they should be handled
-	// as separate children within the element, not as part of the expression
+	// as separate children within elements, not as part of the expression.
 	const shouldSkipLeadingComments =
-		node.type === 'TSRXExpression' || node.type === 'Text' || node.type === 'Html';
+		parentNode?.type === 'Element' &&
+		(node.type === 'TSRXExpression' || node.type === 'Text' || node.type === 'Html');
 
 	// Handle leading comments
 	if (node.leadingComments && !shouldSkipLeadingComments && !suppressLeadingComments) {
@@ -1335,6 +1380,10 @@ function printRippleNode(node, path, options, print, args) {
 				group(indent(line), { id: groupId }),
 				indentIfBreak(rightSide, { groupId }),
 			]);
+			const parent = path.getParentNode();
+			if (assignmentExpressionNeedsParens(node, parent)) {
+				nodeContent = ['(', nodeContent, ')'];
+			}
 			break;
 		}
 
@@ -4296,6 +4345,10 @@ function printTSTypeAliasDeclaration(node, path, options, print) {
 		head.push(path.call(print, 'typeParameters'));
 	}
 
+	if (node.typeAnnotation.type === 'TSTypeLiteral') {
+		return group([head, ' = ', path.call(print, 'typeAnnotation'), semi(options)]);
+	}
+
 	return group([head, ' =', indent([line, path.call(print, 'typeAnnotation')]), semi(options)]);
 }
 
@@ -5926,6 +5979,24 @@ function printJSXElement(node, path, options, print) {
 			// Accumulate text content, preserving spaces between words
 			const trimmed = child.value.trim();
 			if (trimmed) {
+				const nextChild = node.children[i + 1];
+				const afterNextChild = node.children[i + 2];
+				const nextText = afterNextChild?.type === 'JSXText' ? afterNextChild.value.trim() : '';
+				if (
+					tagName === 'tsrx' &&
+					trimmed.endsWith('=') &&
+					nextChild?.type === 'JSXElement' &&
+					nextText === ';'
+				) {
+					if (currentText) {
+						childrenDocs.push(currentText);
+						currentText = '';
+					}
+					childrenDocs.push([trimmed, ' ', path.call(print, 'children', i + 1), ';']);
+					i += 2;
+					continue;
+				}
+
 				if (currentText) {
 					currentText += ' ' + trimmed;
 				} else {

package/src/index.test.js

@@ -200,6 +200,49 @@ describe('prettier-plugin', () => {
 			expect(result).toBeWithNewline(expected);
 		});
 
+		it('should preserve comments before expressions after nested tsx and tsrx blocks', async () => {
+			const input = `component App() {
+	const content = <tsx>
+		{<tsrx>
+			const nested =
+			<tsx>
+				<span class="nested-tsx">
+					{'inside nested tsx'}
+				</span>
+			</tsx>
+			;
+			<div class="native">{nested}</div>
+		</tsrx>}
+	</tsx>;
+
+	// const content = <tsrx>
+	// 	<div>{hey()}</div>
+	// </tsrx>;
+
+	{content}
+}`;
+			const expected = `component App() {
+  const content = <tsx>
+    {<tsrx>
+      const nested = <tsx>
+        <span class="nested-tsx">
+          {'inside nested tsx'}
+        </span>
+      </tsx>;
+      <div class="native">{nested}</div>
+    </tsrx>}
+  </tsx>;
+
+  // const content = <tsrx>
+  // 	<div>{hey()}</div>
+  // </tsrx>;
+
+  {content}
+}`;
+			const result = await format(input, { singleQuote: true });
+			expect(result).toBeWithNewline(expected);
+		});
+
 		it('should break nested TSX element attributes inside expression props', async () => {
 			const cases = [
 				{
@@ -762,6 +805,28 @@ function test() {
 			expect(result).toBeWithNewline(expected);
 		});
 
+		it('should preserve required parentheses around assignment expressions', async () => {
+			const input = `const openSignal = useRef<Signal<boolean> | null>(null)
+const open = props.open ?? (openSignal.current ??= signal(false))
+const sum = a + (b = c)
+const condition = (a = b) ? c : d
+const called = (factory = getFactory())()
+async function load() {
+  await (promise = getPromise())
+}`;
+			const expected = `const openSignal = useRef<Signal<boolean> | null>(null);
+const open = props.open ?? (openSignal.current ??= signal(false));
+const sum = a + (b = c);
+const condition = (a = b) ? c : d;
+const called = (factory = getFactory())();
+async function load() {
+  await (promise = getPromise());
+}`;
+
+			const result = await format(input, { singleQuote: true });
+			expect(result).toBeWithNewline(expected);
+		});
+
 		it('should not change formatting for function object properties and properties in square brackets', async () => {
 			const expected = `export component App() {
   const SYMBOL_PROP = Symbol();
@@ -3607,6 +3672,17 @@ second"</pre>
 			expect(result).toBeWithNewline(expected);
 		});
 
+		it('should not overindent multiline object type aliases', async () => {
+			const input = `type ModuleShape = {
+  default: ComponentType<{ value: string }>;
+}`;
+			const expected = `type ModuleShape = {
+  default: ComponentType<{ value: string }>;
+};`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
 		it('should format TypeScript tuple types (TSTupleType)', async () => {
 			const input = `type T = [string, number, boolean];`;
 			const expected = `type T = [string, number, boolean];`;