@ripple-ts/prettier-plugin 0.2.199 → 0.2.201

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ripple-ts/prettier-plugin",
-  "version": "0.2.199",
+  "version": "0.2.201",
   "description": "Ripple plugin for Prettier",
   "type": "module",
   "module": "src/index.js",
@@ -25,7 +25,7 @@
   },
   "devDependencies": {
     "prettier": "^3.6.2",
-    "ripple": "0.2.199"
+    "ripple": "0.2.201"
   },
   "dependencies": {},
   "files": [

package/src/index.js

@@ -550,6 +550,36 @@ function buildInlineArrayCommentDoc(comments) {
 	return docs.length > 0 ? concat(docs) : null;
 }
 
+/**
+ * @param {AST.Property | AST.MethodDefinition} node
+ */
+function printKey(node, path, options, print) {
+	const parts = [];
+	if (node.computed) {
+		// computed are never converted to identifiers
+		parts.push('[', path.call(print, 'key'), ']');
+		return parts;
+	}
+
+	if (node.key.type === 'Literal' && typeof node.key.value === 'string') {
+		// Check if the key is a valid identifier that doesn't need quotes
+		const key = node.key.value;
+		const isValidIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+
+		if (isValidIdentifier) {
+			// Don't quote valid identifiers
+			parts.push(key);
+		} else {
+			// Quote keys that need it (e.g., contain special characters)
+			parts.push(formatStringLiteral(key, options));
+		}
+	} else {
+		parts.push(path.call(print, 'key'));
+	}
+
+	return parts;
+}
+
 function printRippleNode(node, path, options, print, args) {
 	if (!node || typeof node !== 'object') {
 		return String(node || '');
@@ -682,7 +712,7 @@ function printRippleNode(node, path, options, print, args) {
 			break;
 
 		case 'Component':
-			nodeContent = printComponent(node, path, options, print, innerCommentParts);
+			nodeContent = printComponent(node, path, options, print, innerCommentParts, args);
 			break;
 
 		case 'ExportNamedDeclaration':
@@ -2200,9 +2230,20 @@ function printExportNamedDeclaration(node, path, options, print) {
 	return 'export';
 }
 
-function printComponent(node, path, options, print, innerCommentParts = []) {
+function printComponent(
+	node,
+	path,
+	options,
+	print,
+	innerCommentParts = [],
+	args = { skipComponentLabel: false },
+) {
 	// Use arrays instead of string concatenation
-	const signatureParts = node.id ? ['component ', node.id.name] : ['component'];
+	const signatureParts = args.skipComponentLabel
+		? []
+		: node.id
+			? ['component ', node.id.name]
+			: ['component'];
 
 	// Add TypeScript generics if present
 	if (node.typeParameters) {
@@ -3106,9 +3147,24 @@ function printObjectExpression(node, path, options, print, args) {
 				propertyParts.push(',');
 
 				// Check for blank lines between properties and preserve them
+				// Need to account for trailing comments on previous property and
+				// leading comments on current property
 				const prevProp = node.properties[i - 1];
 				const currentProp = node.properties[i];
-				if (prevProp && currentProp && getBlankLinesBetweenNodes(prevProp, currentProp) > 0) {
+
+				// Determine the source node (end of previous property or its trailing comments)
+				let sourceNode = prevProp;
+				if (prevProp?.trailingComments?.length > 0) {
+					sourceNode = prevProp.trailingComments[prevProp.trailingComments.length - 1];
+				}
+
+				// Determine the target node (start of current property or its leading comments)
+				let targetNode = currentProp;
+				if (currentProp?.leadingComments?.length > 0) {
+					targetNode = currentProp.leadingComments[0];
+				}
+
+				if (sourceNode && targetNode && getBlankLinesBetweenNodes(sourceNode, targetNode) > 0) {
 					propertyParts.push(hardline);
 					propertyParts.push(hardline); // Two hardlines = blank line
 				} else {
@@ -3259,6 +3315,7 @@ function printPropertyDefinition(node, path, options, print) {
 
 function printMethodDefinition(node, path, options, print) {
 	const parts = [];
+	const is_component = node.value?.type === 'Component';
 
 	// Access modifiers (public, private, protected)
 	if (node.accessibility) {
@@ -3271,24 +3328,37 @@ function printMethodDefinition(node, path, options, print) {
 		parts.push('static ');
 	}
 
-	// Async keyword
-	if (node.value && node.value.async) {
-		parts.push('async ');
-	}
-
 	// Method kind and name
 	if (node.kind === 'constructor') {
-		parts.push('constructor');
+		// skip as it's covered by the key
 	} else if (node.kind === 'get') {
 		parts.push('get ');
-		parts.push(path.call(print, 'key'));
 	} else if (node.kind === 'set') {
 		parts.push('set ');
-		parts.push(path.call(print, 'key'));
-	} else {
-		parts.push(path.call(print, 'key'));
 	}
 
+	// Async keyword
+	if (node.value && node.value.async) {
+		parts.push('async ');
+	}
+
+	if (node.value.generator) {
+		parts.push('*');
+	}
+
+	if (is_component) {
+		if (node.value.id) {
+			// takes care of component methods
+			parts.push(path.call(print, 'value'));
+			return concat(parts);
+		}
+
+		parts.push('component ');
+	}
+
+	// the key is 'constructor' and we already handled that above
+	parts.push(...printKey(node, path, options, print));
+
 	// Add TypeScript generics if present (always on the method node, not on value)
 	if (node.typeParameters) {
 		const typeParams = path.call(print, 'typeParameters');
@@ -3299,6 +3369,13 @@ function printMethodDefinition(node, path, options, print) {
 		}
 	}
 
+	if (is_component) {
+		parts.push(
+			...path.call((childPath) => print(childPath, { skipComponentLabel: true }), 'value'),
+		);
+		return concat(parts);
+	}
+
 	// Parameters - use proper path.map for TypeScript support
 	parts.push('(');
 	if (node.value && node.value.params && node.value.params.length > 0) {
@@ -3960,7 +4037,7 @@ function printProperty(node, path, options, print) {
 		return path.call(print, 'key');
 	}
 
-	const parts = [];
+	const is_component = node.value?.type === 'Component';
 
 	// Handle getter/setter methods
 	if (node.kind === 'get' || node.kind === 'set') {
@@ -3970,20 +4047,7 @@ function printProperty(node, path, options, print) {
 		// Add get/set keyword
 		methodParts.push(node.kind, ' ');
 
-		// Print key (with computed property brackets if needed)
-		if (node.computed) {
-			methodParts.push('[', path.call(print, 'key'), ']');
-		} else if (node.key.type === 'Literal' && typeof node.key.value === 'string') {
-			const key = node.key.value;
-			const isValidIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
-			if (isValidIdentifier) {
-				methodParts.push(key);
-			} else {
-				methodParts.push(formatStringLiteral(key, options));
-			}
-		} else {
-			methodParts.push(path.call(print, 'key'));
-		}
+		methodParts.push(...printKey(node, path, options, print));
 
 		// Print parameters by calling into the value path
 		const paramsPart = path.call(
@@ -4002,7 +4066,7 @@ function printProperty(node, path, options, print) {
 	}
 
 	// Handle method shorthand: increment() {} instead of increment: function() {}
-	if (node.method && node.value.type === 'FunctionExpression') {
+	if (node.method && (node.value.type === 'FunctionExpression' || is_component)) {
 		const methodParts = [];
 		const funcValue = node.value;
 
@@ -4011,26 +4075,23 @@ function printProperty(node, path, options, print) {
 			methodParts.push('async ');
 		}
 
-		// Print key (with computed property brackets if needed)
-		if (node.computed) {
-			methodParts.push('[', path.call(print, 'key'), ']');
-		} else if (node.key.type === 'Literal' && typeof node.key.value === 'string') {
-			// Check if the key is a valid identifier that doesn't need quotes
-			const key = node.key.value;
-			const isValidIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
-			if (isValidIdentifier) {
-				methodParts.push(key);
-			} else {
-				methodParts.push(formatStringLiteral(key, options));
-			}
-		} else {
-			methodParts.push(path.call(print, 'key'));
+		if (is_component) {
+			methodParts.push('component ');
 		}
 
 		if (funcValue.generator) {
 			methodParts.push('*');
 		}
 
+		methodParts.push(...printKey(node, path, options, print));
+
+		if (is_component) {
+			methodParts.push(
+				path.call((childPath) => print(childPath, { skipComponentLabel: true }), 'value'),
+			);
+			return concat(methodParts);
+		}
+
 		// Print parameters by calling into the value path
 		const paramsPart = path.call(
 			(valuePath) => printFunctionParameters(valuePath, options, print),
@@ -4047,27 +4108,8 @@ function printProperty(node, path, options, print) {
 		return concat(methodParts);
 	}
 
-	// Handle property key - if it's a Literal (quoted string in source),
-	// check if it needs quotes or can be unquoted
-	if (node.computed) {
-		// Computed property: [key]
-		parts.push('[', path.call(print, 'key'), ']');
-	} else if (node.key.type === 'Literal' && typeof node.key.value === 'string') {
-		// Check if the key is a valid identifier that doesn't need quotes
-		const key = node.key.value;
-		const isValidIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
-
-		if (isValidIdentifier) {
-			// Don't quote valid identifiers
-			parts.push(key);
-		} else {
-			// Quote keys that need it (e.g., contain special characters)
-			parts.push(formatStringLiteral(key, options));
-		}
-	} else {
-		// For non-literal keys, print normally
-		parts.push(path.call(print, 'key'));
-	}
+	const parts = [];
+	parts.push(...printKey(node, path, options, print));
 
 	parts.push(': ');
 	parts.push(path.call(print, 'value'));

package/src/index.test.js

@@ -1781,6 +1781,116 @@ files = [...(files ?? []), ...dt.files];`;
 			const result = await format(expected, { singleQuote: true, printWidth: 100 });
 			expect(result).toBeWithNewline(expected);
 		});
+
+		it('should preserve class component method', async () => {
+			const expected = `class TestClass {
+  component something() {
+    <div>{'Nested component'}</div>
+  }
+}`;
+
+			const result = await format(expected, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should preserve class computed method', async () => {
+			const expected = `class TestClass {
+  ['something']() {
+    const i = 10;
+  }
+}`;
+
+			const result = await format(expected, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should preserve class computed component method', async () => {
+			const expected = `class TestClass {
+  component ['something']() {
+    <div>{'Nested component'}</div>
+  }
+}`;
+
+			const result = await format(expected, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should format class with a literal component method', async () => {
+			const input = `class TestClass {
+  component 'something'() {
+    <div>{'Nested component'}</div>
+  }
+}`;
+
+			const expected = `class TestClass {
+  component something() {
+    <div>{'Nested component'}</div>
+  }
+}`;
+
+			const result = await format(input, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should preserve object component methods', async () => {
+			const expected = `const obj = {
+  component something() {
+    <div>{'Nested component'}</div>
+  },
+};`;
+
+			const result = await format(expected, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should preserve object computed methods', async () => {
+			const expected = `const obj = {
+  ['something']() {
+    const i = 10;
+  },
+};`;
+
+			const result = await format(expected, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should preserve object computed component method', async () => {
+			const expected = `const obj = {
+  component ['something']() {
+    <div>{'Nested component'}</div>
+  },
+};`;
+
+			const result = await format(expected, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should format object with a literal component method', async () => {
+			const input = `const obj = {
+  component 'something'() {
+    <div>{'Nested component'}</div>
+  },
+};`;
+			const expected = `const obj = {
+  component something() {
+    <div>{'Nested component'}</div>
+  },
+};`;
+
+			const result = await format(input, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should print class constructor method only once', async () => {
+			const expected = `class TestClass {
+  constructor(value: T) {
+    this.value = value;
+  }
+}`;
+
+			const result = await format(expected, { singleQuote: true, printWidth: 100 });
+			expect(result).toBeWithNewline(expected);
+		});
 	});
 
 	describe('edge cases', () => {
@@ -2110,6 +2220,21 @@ const obj2 = #{
 		expect(result).toBeWithNewline(expected);
 	});
 
+	it('should not add an extra new line above a comment inside objects and in between properties', async () => {
+		const expected = `let obj = {
+  ['hey']: function () {
+    const i = 'yo';
+  },
+  // <div>{'Weird name component'}</div>
+  normal() {
+    const b = 'hey';
+  },
+};`;
+
+		const result = await format(expected, { singleQuote: true });
+		expect(result).toBeWithNewline(expected);
+	});
+
 	it('should preserve comment if the whole component code is commented out', async () => {
 		const expected = `export component Test() {
   // thing
@@ -2939,6 +3064,10 @@ try {
   {
     "id": "toast:6",
     "stacked": false,
+  },
+  {
+    ["id"]: "toast:6",
+    ["stacked"]: false,
   }
 ];`;
 
@@ -2963,6 +3092,10 @@ try {
     id: 'toast:6',
     stacked: false,
   },
+  {
+    ['id']: 'toast:6',
+    ['stacked']: false,
+  },
 ];`;
 
 			const result = await format(input, { singleQuote: true, arrowParens: 'always' });