@putout/printer 15.18.0 → 15.18.1

package/ChangeLog

@@ -1,3 +1,8 @@
+2025.08.05, v15.18.1
+
+feature:
+- 59d5952 @putout/printer: AssignmentExpression: maybeParens
+
 2025.08.04, v15.18.0
 
 feature:

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

@@ -2,9 +2,10 @@
 
 const {types} = require('@putout/babel');
 const {hasLeadingComment} = require('#is');
+const noop = () => {};
 const {isReturnStatement} = types;
 
-module.exports.printLeadingCommentLine = ({parentPath}) => !isReturnStatement(parentPath);
+module.exports.printLeadingCommentLine = noop;
 
 module.exports.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
     const {parentPath} = path;
@@ -34,4 +35,3 @@ module.exports.maybeInsideReturnWithCommentEnd = (path, {print, indent}) => {
     indent.dec();
     print.breakline();
 };
-

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

@@ -1,11 +1,6 @@
 'use strict';
 
-const {types} = require('@putout/babel');
-
-const {
-    maybePrintLeftBrace,
-    maybePrintRightBrace,
-} = require('./maybe-write-brace');
+const {condition} = require('./maybe-parens-condition');
 
 const {
     printLeadingCommentLine,
@@ -13,48 +8,33 @@ const {
     maybeInsideReturnWithCommentStart,
 } = require('./assignment-expression-comments');
 
-const {
-    isExpressionStatement,
-    isAssignmentExpression,
-} = types;
+const {maybeParens} = require('../../maybe/maybe-parens');
+const {printSeparator} = require('./print-separator');
 
 const isInsideBlock = ({parentPath}) => /BlockStatement|Program/.test(parentPath.type);
 
-module.exports.AssignmentExpression = (path, printer, semantics) => {
-    const {print} = printer;
-    const {operator} = path.node;
-    
-    maybePrintLeftBrace(path, printer, semantics);
-    maybeInsideReturnWithCommentStart(path, printer);
-    
-    print('__left');
-    print.space();
-    print(operator);
-    
-    if (isMultiline(path))
-        print.breakline();
-    else
+module.exports.AssignmentExpression = maybeParens({
+    checkParens: false,
+    condition,
+    print(path, printer) {
+        const {print} = printer;
+        const {operator} = path.node;
+        
+        maybeInsideReturnWithCommentStart(path, printer);
+        
+        print('__left');
         print.space();
-    
-    print('__right');
-    
-    if (isInsideBlock(path)) {
-        print(';');
-        print.breakline();
-    }
-    
-    maybeInsideReturnWithCommentEnd(path, printer);
-    
-    maybePrintRightBrace(path, printer, semantics);
-};
+        print(operator);
+        printSeparator(path, printer);
+        print('__right');
+        
+        if (isInsideBlock(path)) {
+            print(';');
+            print.breakline();
+        }
+        
+        maybeInsideReturnWithCommentEnd(path, printer);
+    },
+});
 
 module.exports.AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine;
-
-function isMultiline(path) {
-    const {right} = path.node;
-    
-    if (!path.parentPath.find(isExpressionStatement))
-        return false;
-    
-    return isAssignmentExpression(right);
-}

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

@@ -0,0 +1,27 @@
+'use strict';
+
+const {hasLeadingComment} = require('#is');
+const {isParens} = require('../../maybe/maybe-parens');
+
+module.exports.condition = (path, printer, semantics) => {
+    const {parentPath} = path;
+    const {type} = parentPath;
+    const {roundBraces} = semantics;
+    
+    if (path.node.left.type === 'ObjectPattern')
+        return true;
+    
+    if (type === 'LogicalExpression')
+        return true;
+    
+    if (type === 'BinaryExpression')
+        return true;
+    
+    if (type === 'UnaryExpression')
+        return true;
+    
+    if (!roundBraces.assign && !hasLeadingComment(path))
+        return false;
+    
+    return isParens(path);
+};

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

@@ -0,0 +1,23 @@
+'use strict';
+
+const {types} = require('@putout/babel');
+const {
+    isAssignmentExpression,
+    isExpressionStatement,
+} = types;
+
+module.exports.printSeparator = (path, {print}) => {
+    if (isMultiline(path))
+        print.breakline();
+    else
+        print.space();
+};
+
+function isMultiline(path) {
+    const {right} = path.node;
+    
+    if (!path.parentPath.find(isExpressionStatement))
+        return false;
+    
+    return isAssignmentExpression(right);
+}

package/lib/tokenize/maybe/maybe-parens.js

@@ -22,7 +22,14 @@ const maybeParensPrint = (print) => ({
     },
 });
 
-const maybeParensCondition = ({print, condition}) => ({
+const maybeParensCondition = ({print, condition, checkParens = true}) => ({
     ...maybeParensPrint(print),
-    condition: (path) => condition?.(path) || isParens(path),
+    condition: (path, print, semantics) => {
+        const is = condition?.(path, print, semantics);
+        
+        if (!checkParens)
+            return is;
+        
+        return is || isParens(path);
+    },
 });

package/package.json

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

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

@@ -1,51 +0,0 @@
-'use strict';
-
-const {hasLeadingComment} = require('#is');
-const {isParens} = require('../../maybe/maybe-parens');
-
-module.exports.maybePrintLeftBrace = (path, printer, semantics) => {
-    maybeWriteBrace(path, printer, semantics, {
-        brace: '(',
-    });
-};
-
-module.exports.maybePrintRightBrace = (path, printer, semantics) => {
-    maybeWriteBrace(path, printer, semantics, {
-        brace: ')',
-    });
-};
-
-function maybeWriteBrace(path, printer, semantics, {brace}) {
-    const {parentPath} = path;
-    const {type} = parentPath;
-    const {roundBraces} = semantics;
-    const {write} = printer;
-    
-    if (path.node.left.type === 'ObjectPattern') {
-        write(brace);
-        return;
-    }
-    
-    if (type === 'LogicalExpression') {
-        write(brace);
-        return;
-    }
-    
-    if (type === 'BinaryExpression') {
-        write(brace);
-        return;
-    }
-    
-    if (type === 'UnaryExpression') {
-        write(brace);
-        return;
-    }
-    
-    if (!roundBraces.assign && !hasLeadingComment(path))
-        return;
-    
-    if (!isParens(path))
-        return;
-    
-    write(brace);
-}