@tsrx/prettier-plugin 0.3.86 → 0.3.87

package/package.json

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

package/src/index.js

@@ -223,6 +223,32 @@ function hasComment(node) {
 	return !!(node.leadingComments || node.trailingComments || node.innerComments);
 }
 
+/**
+ * Check whether a comment is a `prettier-ignore` directive.
+ * @param {AST.Comment | undefined} comment - The comment to check
+ * @returns {boolean} - True if the comment reads exactly `prettier-ignore`
+ */
+function isPrettierIgnoreComment(comment) {
+	if (!comment || (comment.type !== 'Line' && comment.type !== 'Block')) {
+		return false;
+	}
+	return comment.value.trim() === 'prettier-ignore';
+}
+
+/**
+ * Check whether a node is immediately preceded by a `prettier-ignore` directive.
+ * Only the last leading comment counts, matching Prettier core.
+ * @param {AST.Node & AST.NodeWithMaybeComments} node - The AST node to check
+ * @returns {boolean} - True if the node should be printed verbatim
+ */
+function hasPrettierIgnore(node) {
+	const comments = node.leadingComments;
+	if (!comments || comments.length === 0) {
+		return false;
+	}
+	return isPrettierIgnoreComment(comments[comments.length - 1]);
+}
+
 /**
  * @param {AST.FunctionDeclaration | AST.FunctionExpression | AST.ArrowFunctionExpression | AST.TSDeclareFunction} node - The function node
  * @returns {Array<AST.Pattern | AST.Parameter>} - Array of parameter patterns
@@ -722,6 +748,70 @@ function printKey(node, path, options, print) {
 	return parts;
 }
 
+/**
+ * Combine already-printed leading comment parts, a node's printed body, and its
+ * trailing comments into the final Doc returned by {@link printRippleNode}.
+ * @param {AST.Node} node - The AST node
+ * @param {Doc[]} parts - Leading-comment parts already collected for the node
+ * @param {Doc[] | Doc} nodeContent - The printed body of the node
+ * @returns {Doc[] | Doc}
+ */
+function finishRippleNode(node, parts, nodeContent) {
+	// Handle trailing comments
+	if (node.trailingComments) {
+		const trailingParts = [];
+		let previousComment = null;
+
+		for (let i = 0; i < node.trailingComments.length; i++) {
+			const comment = node.trailingComments[i];
+			const isInlineComment = Boolean(
+				node.loc && comment.loc && node.loc.end.line === comment.loc.start.line,
+			);
+
+			const commentDoc =
+				comment.type === 'Line' ? '//' + comment.value : '/*' + comment.value + '*/';
+
+			if (isInlineComment) {
+				if (comment.type === 'Line') {
+					trailingParts.push(lineSuffix([' ', commentDoc]));
+					trailingParts.push(breakParent);
+				} else {
+					trailingParts.push(' ' + commentDoc);
+				}
+			} else {
+				const refs = [];
+				refs.push(hardline);
+
+				const blankLinesBetween = previousComment
+					? getBlankLinesBetweenNodes(previousComment, comment)
+					: getBlankLinesBetweenNodes(node, comment);
+				if (blankLinesBetween > 0) {
+					refs.push(hardline);
+				}
+
+				refs.push(commentDoc);
+				trailingParts.push(lineSuffix(refs));
+			}
+
+			previousComment = comment;
+		}
+
+		if (trailingParts.length > 0) {
+			parts.push(nodeContent);
+			parts.push(...trailingParts);
+			return parts;
+		}
+	} // Return with or without leading comments
+	if (parts.length > 0) {
+		// Don't add blank line between leading comments and node
+		// because they're meant to be attached together
+		parts.push(nodeContent);
+		return parts;
+	}
+
+	return nodeContent;
+}
+
 /**
  * Main print function for Ripple AST nodes
  * @param {AST.Node | AST.CSS.StyleSheet} node - The AST node to print
@@ -812,6 +902,23 @@ function printRippleNode(node, path, options, print, args) {
 		}
 	}
 
+	// A `prettier-ignore` directive keeps the node's original source verbatim.
+	const commentNode = /** @type {AST.Node & AST.NodeWithMaybeComments} */ (node);
+	const ignoreStart = /** @type {AST.NodeWithLocation} */ (node).start;
+	const ignoreEnd = /** @type {AST.NodeWithLocation} */ (node).end;
+	if (
+		hasPrettierIgnore(commentNode) &&
+		typeof options.originalText === 'string' &&
+		typeof ignoreStart === 'number' &&
+		typeof ignoreEnd === 'number'
+	) {
+		return finishRippleNode(
+			commentNode,
+			parts,
+			replaceEndOfLine(options.originalText.slice(ignoreStart, ignoreEnd)),
+		);
+	}
+
 	/** @type {Doc[] | Doc} */
 	let nodeContent;
 
@@ -2338,64 +2445,7 @@ function printRippleNode(node, path, options, print, args) {
 			break;
 	}
 
-	// Handle trailing comments
-	if (node.trailingComments) {
-		const trailingParts = [];
-		let previousComment = null;
-
-		for (let i = 0; i < node.trailingComments.length; i++) {
-			const comment = node.trailingComments[i];
-			const isInlineComment = Boolean(
-				node.loc && comment.loc && node.loc.end.line === comment.loc.start.line,
-			);
-
-			const commentDoc =
-				comment.type === 'Line' ? '//' + comment.value : '/*' + comment.value + '*/';
-
-			if (isInlineComment) {
-				if (comment.type === 'Line') {
-					trailingParts.push(lineSuffix([' ', commentDoc]));
-					trailingParts.push(breakParent);
-				} else {
-					trailingParts.push(' ' + commentDoc);
-				}
-			} else {
-				const refs = [];
-				refs.push(hardline);
-
-				const blankLinesBetween = previousComment
-					? getBlankLinesBetweenNodes(previousComment, comment)
-					: getBlankLinesBetweenNodes(node, comment);
-				if (blankLinesBetween > 0) {
-					refs.push(hardline);
-				}
-
-				if (comment.type === 'Line') {
-					refs.push(commentDoc);
-					trailingParts.push(lineSuffix(refs));
-				} else {
-					refs.push(commentDoc);
-					trailingParts.push(lineSuffix(refs));
-				}
-			}
-
-			previousComment = comment;
-		}
-
-		if (trailingParts.length > 0) {
-			parts.push(nodeContent);
-			parts.push(...trailingParts);
-			return parts;
-		}
-	} // Return with or without leading comments
-	if (parts.length > 0) {
-		// Don't add blank line between leading comments and node
-		// because they're meant to be attached together
-		parts.push(nodeContent);
-		return parts;
-	}
-
-	return nodeContent;
+	return finishRippleNode(/** @type {AST.Node} */ (node), parts, nodeContent);
 }
 
 /**

package/src/index.test.js

@@ -851,6 +851,89 @@ const items=[1,2,3];
 		expect(result).toBeWithNewline(expected);
 	});
 
+	describe('prettier-ignore', () => {
+		it('preserves a statement verbatim after a line directive', async () => {
+			const input = `export function App() {
+	// prettier-ignore
+	const matrix = [1,0,0,
+		0,1,0,
+		0,0,1];
+	return <div>{matrix.length}</div>;
+}`;
+			const expected = `export function App() {
+  // prettier-ignore
+  const matrix = [1,0,0,
+		0,1,0,
+		0,0,1];
+  return <div>{matrix.length}</div>;
+}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('preserves a statement verbatim after a block directive', async () => {
+			const input = `export function App() {
+	/* prettier-ignore */
+	const obj = {a:1,     b:2};
+	return <div>{obj.a}</div>;
+}`;
+			const expected = `export function App() {
+  /* prettier-ignore */
+  const obj = {a:1,     b:2};
+  return <div>{obj.a}</div>;
+}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('preserves a JSX element verbatim', async () => {
+			const input = `export function App() @{
+	// prettier-ignore
+	<div   class="x"     id="y">
+		hello
+	</div>
+}`;
+			const expected = `export function App() @{
+  // prettier-ignore
+  <div   class="x"     id="y">
+		hello
+	</div>
+}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('preserves a whitespace-only fragment verbatim', async () => {
+			const input = `function WhitespaceOnlyApp() @{
+	// prettier-ignore
+	<>
+	</>
+}`;
+			const expected = `function WhitespaceOnlyApp() @{
+  // prettier-ignore
+  <>
+	</>
+}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+
+		it('still formats when the comment is not a prettier-ignore directive', async () => {
+			const input = `export function App() {
+	// this is a normal comment
+	const obj = {a:1,     b:2};
+	return <div>{obj.a}</div>;
+}`;
+			const expected = `export function App() {
+  // this is a normal comment
+  const obj = { a: 1, b: 2 };
+  return <div>{obj.a}</div>;
+}`;
+			const result = await format(input);
+			expect(result).toBeWithNewline(expected);
+		});
+	});
+
 	describe('recovered', () => {
 		/**
 		 * @param {string} code