@putout/printer 15.18.1 → 15.19.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2025.08.05, v15.19.0
+
+feature:
+- f518cd6 @putout/printer: SequenceExpression: leadingComments inside AssignmentExpressions: improve
+
+2025.08.05, v15.18.2
+
+feature:
+- a7fd7cc @putout/printer: AssignmentExpression: comments: inside SequenceExpression
+
 2025.08.05, v15.18.1
 
 feature:

package/lib/tokenize/expressions/assignment-expression/assignment-expression-comments.js

@@ -2,15 +2,36 @@
 
 const {types} = require('@putout/babel');
 const {hasLeadingComment} = require('#is');
-const noop = () => {};
 const {isReturnStatement} = types;
 
-module.exports.printLeadingCommentLine = noop;
+module.exports.printLeadingCommentLine = (path, printer, semantics, {printComment, isLast}) => {
+    const {parentPath} = path;
+    const {print, maybe} = printer;
+    
+    if (isReturnStatement(parentPath))
+        return;
+    
+    maybe.print.breakline(!isLast);
+    printComment();
+    print.breakline();
+};
+
+module.exports.printLeadingCommentBlock = (path, printer, semantics, {printComment}) => {
+    const {parentPath} = path;
+    const {print} = printer;
+    
+    if (isReturnStatement(parentPath))
+        return;
+    
+    printComment();
+    print.indent();
+};
 
 module.exports.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
     const {parentPath} = path;
+    const is = isReturnStatement(parentPath);
     
-    if (isReturnStatement(parentPath) && hasLeadingComment(path)) {
+    if (is && hasLeadingComment(path)) {
         indent.inc();
         const {leadingComments} = path.node;
         
@@ -28,8 +49,9 @@ module.exports.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
 
 module.exports.maybeInsideReturnWithCommentEnd = (path, {print, indent}) => {
     const {parentPath} = path;
+    const is = isReturnStatement(parentPath);
     
-    if (!isReturnStatement(parentPath) || !hasLeadingComment(path))
+    if (!is || !hasLeadingComment(path))
         return;
     
     indent.dec();

package/lib/tokenize/expressions/assignment-expression/assignment-expression.js

@@ -6,6 +6,7 @@ const {
     printLeadingCommentLine,
     maybeInsideReturnWithCommentEnd,
     maybeInsideReturnWithCommentStart,
+    printLeadingCommentBlock,
 } = require('./assignment-expression-comments');
 
 const {maybeParens} = require('../../maybe/maybe-parens');
@@ -38,3 +39,4 @@ module.exports.AssignmentExpression = maybeParens({
 });
 
 module.exports.AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine;
+module.exports.AssignmentExpression.printLeadingCommentBlock = printLeadingCommentBlock;

package/lib/tokenize/expressions/assignment-expression/maybe-parens-condition.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {hasLeadingComment} = require('#is');
+
 const {isParens} = require('../../maybe/maybe-parens');
 
 module.exports.condition = (path, printer, semantics) => {

package/lib/tokenize/expressions/sequence-expression/maybe-write-brace.js

@@ -1,40 +1,18 @@
 'use strict';
 
-module.exports.maybeWriteLeftBrace = (path, printer, semantics) => {
-    maybeWriteBrace(path, printer, semantics, {
-        brace: '(',
-    });
-};
-
-module.exports.maybeWriteRightBrace = (path, printer, semantics) => {
-    maybeWriteBrace(path, printer, semantics, {
-        brace: ')',
-    });
-};
-
-function maybeWriteBrace(path, printer, semantics, {brace}) {
+module.exports.condition = (path, printer, semantics) => {
     const {parentPath} = path;
     const {type} = parentPath;
     const {roundBraces} = semantics;
-    const {write} = printer;
-    
-    if (type === 'ArrowFunctionExpression') {
-        write(brace);
-        return;
-    }
     
-    if (type === 'ConditionalExpression' && path !== parentPath.get('test')) {
-        write(brace);
-        return;
-    }
+    if (type === 'ArrowFunctionExpression')
+        return true;
     
-    if (type === 'LogicalExpression') {
-        write(brace);
-        return;
-    }
+    if (type === 'ConditionalExpression' && path !== parentPath.get('test'))
+        return true;
     
-    if (!roundBraces.sequence)
-        return;
+    if (type === 'LogicalExpression')
+        return true;
     
-    write(brace);
-}
+    return roundBraces.sequence;
+};

package/lib/tokenize/expressions/sequence-expression/sequence-expression-comments.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const {hasLeadingComment} = require('#is');
+const noop = () => {};
+
+module.exports.printLeadingCommentLine = noop;
+module.exports.printLeadingCommentBlock = noop;
+
+module.exports.maybePrintComments = (path, {print}) => {
+    if (hasLeadingComment(path)) {
+        const {leadingComments} = path.node;
+        
+        for (const {type, value} of leadingComments) {
+            if (type === 'CommentLine')
+                print(`//${value}`);
+            else
+                print(`/*${value}*/`);
+            
+            print.breakline();
+        }
+    }
+};

package/lib/tokenize/expressions/sequence-expression/sequence-expression.js

@@ -1,23 +1,53 @@
 'use strict';
 
+const {hasLeadingComment} = require('#is');
+const {maybeParens} = require('../../maybe/maybe-parens');
+const {condition} = require('./maybe-write-brace');
+
 const {
-    maybeWriteLeftBrace,
-    maybeWriteRightBrace,
-} = require('./maybe-write-brace');
+    maybePrintComments,
+    printLeadingCommentLine,
+    printLeadingCommentBlock,
+} = require('./sequence-expression-comments');
+
+module.exports.SequenceExpression = maybeParens({
+    checkParens: false,
+    condition,
+    print(path, printer) {
+        const {
+            write,
+            traverse,
+            indent,
+            maybe,
+        } = printer;
+        
+        const expressions = path.get('expressions');
+        const n = expressions.length - 1;
+        
+        const withComment = hasLeadingComment(path);
+        
+        if (withComment) {
+            indent.inc();
+            write.breakline();
+            maybePrintComments(path, printer);
+        }
+        
+        for (const [index, expression] of expressions.entries()) {
+            traverse(expression);
+            
+            if (index < n) {
+                write(',');
+                maybe.write.space(!withComment);
+                maybe.print.breakline(withComment);
+            }
+        }
+        
+        if (withComment) {
+            indent.dec();
+            write.breakline();
+        }
+    },
+});
 
-module.exports.SequenceExpression = (path, printer, semantics) => {
-    const {maybe, traverse} = printer;
-    
-    const expressions = path.get('expressions');
-    const n = expressions.length - 1;
-    
-    maybeWriteLeftBrace(path, printer, semantics);
-    
-    for (const [index, expression] of expressions.entries()) {
-        traverse(expression);
-        maybe.write(index < n, ',');
-        maybe.write.space(index < n);
-    }
-    
-    maybeWriteRightBrace(path, printer, semantics);
-};
+module.exports.SequenceExpression.printLeadingCommentLine = printLeadingCommentLine;
+module.exports.SequenceExpression.printLeadingCommentBlock = printLeadingCommentBlock;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "15.18.1",
+  "version": "15.19.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",