@ripple-ts/prettier-plugin 0.2.156 → 0.2.157

package/package.json

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

package/src/index.js

@@ -1163,10 +1163,14 @@ function printRippleNode(node, path, options, print, args) {
 			break;
 		}
 
+		case 'TSNonNullExpression': {
+			nodeContent = concat([path.call(print, 'expression'), '!']);
+			break;
+		}
+
 		case 'NewExpression':
 			nodeContent = printNewExpression(node, path, options, print);
 			break;
-
 		case 'TemplateLiteral':
 			nodeContent = printTemplateLiteral(node, path, options, print);
 			break;
@@ -1324,8 +1328,10 @@ function printRippleNode(node, path, options, print, args) {
 			const trackedPrefix = node.tracked ? '@' : '';
 			let identifierContent;
 			if (node.typeAnnotation) {
+				const optionalMarker = node.optional ? '?' : '';
 				identifierContent = concat([
 					trackedPrefix + node.name,
+					optionalMarker,
 					': ',
 					path.call(print, 'typeAnnotation'),
 				]);
@@ -1348,7 +1354,6 @@ function printRippleNode(node, path, options, print, args) {
 			}
 			break;
 		}
-
 		case 'Literal':
 			// Handle regex literals specially
 			if (node.regex) {
@@ -1645,10 +1650,13 @@ function printRippleNode(node, path, options, print, args) {
 			nodeContent = printTSPropertySignature(node, path, options, print);
 			break;
 
+		case 'TSMethodSignature':
+			nodeContent = printTSMethodSignature(node, path, options, print);
+			break;
+
 		case 'TSEnumMember':
 			nodeContent = printTSEnumMember(node, path, options, print);
 			break;
-
 		case 'TSLiteralType':
 			nodeContent = path.call(print, 'literal');
 			break;
@@ -3863,6 +3871,47 @@ function printTSPropertySignature(node, path, options, print) {
 	return concat(parts);
 }
 
+function printTSMethodSignature(node, path, options, print) {
+	const parts = [];
+
+	// Print the method name/key
+	parts.push(path.call(print, 'key'));
+
+	// Add optional marker if present
+	if (node.optional) {
+		parts.push('?');
+	}
+
+	// Add TypeScript generics/type parameters if present
+	if (node.typeParameters) {
+		const typeParams = path.call(print, 'typeParameters');
+		if (Array.isArray(typeParams)) {
+			parts.push(...typeParams);
+		} else {
+			parts.push(typeParams);
+		}
+	}
+
+	// Print parameters - use 'parameters' property for TypeScript signature nodes
+	parts.push('(');
+	if (node.parameters && node.parameters.length > 0) {
+		const params = path.map(print, 'parameters');
+		for (let i = 0; i < params.length; i++) {
+			if (i > 0) parts.push(', ');
+			parts.push(params[i]);
+		}
+	}
+	parts.push(')');
+
+	// Return type annotation
+	if (node.typeAnnotation) {
+		parts.push(': ');
+		parts.push(path.call(print, 'typeAnnotation'));
+	}
+
+	return concat(parts);
+}
+
 function printTSTypeReference(node, path, options, print) {
 	const parts = [path.call(print, 'typeName')];
 

package/src/index.test.js

@@ -2282,6 +2282,44 @@ const items = [] as unknown[];`;
 			expect(result).toBeWithNewline(expected);
 		});
 
+		it('should format TSMethodSignature in interfaces', async () => {
+			const input = `interface API{get(path:string):Promise<Response>;post<T>(path:string,data:T):Promise<Response>;delete?(id:number):void}`;
+			const expected = `interface API {
+  get(path: string): Promise<Response>;
+  post<T>(path: string, data: T): Promise<Response>;
+  delete?(id: number): void;
+}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should format TSMethodSignature with type parameters', async () => {
+			const input = `interface Collection{map<U>(fn:(item:T)=>U):U[];filter(predicate:(item:T)=>boolean):T[]}`;
+			const expected = `interface Collection {\n  map<U>(fn: (item: T) => U): U[];\n  filter(predicate: (item: T) => boolean): T[];\n}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should format TSNonNullExpression', async () => {
+			const input = `component Test(){let value:string|null=null;let length=value!.length;<div>{length}</div>}`;
+			const expected = `component Test() {
+  let value: string | null = null;
+  let length = value!.length;
+  <div>{length}</div>
+}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('should format TSNonNullExpression in complex expressions', async () => {
+			const input = `function getValue(x?:string){return x!.toUpperCase()}`;
+			const expected = `function getValue(x?: string) {
+  return x!.toUpperCase();
+}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
 		it('should retain templated declarations', async () => {
 			const expected = `function Wrapper() {
   return {