@putout/printer 9.0.2 → 9.1.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2024.06.09, v9.1.0
+
+feature:
+- 82ddbc3 @putout/printer: semantics: roundBraces: add support of AssignmentExpression (@putoutjs/minify#15)
+
+2024.06.07, v9.0.3
+
+feature:
+- a254ee6 @putout/printer: SequenceExpression maybe-write-brace
+
 2024.06.07, v9.0.2
 
 feature:

package/README.md

@@ -177,6 +177,7 @@ Options used to configure logic of output, similar to ESLint rules:
 - ✅ `roundBraces` to output braces or not
   - In a  single argument arrow function expressions `(a) => {}` or not `a => {}`;
   - In sequence expressions: `for(let e of l) (a(), b())` or not `for(let e of l) a(), b()`;
+  - In assignment expressions: `(e.o=w(e.o)` or not `e.o=w(e.o)`;
 
 ## Visitors API
 

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

@@ -1,38 +1,24 @@
 'use strict';
 
-const {isObjectPattern} = require('@putout/babel').types;
-const {isParens} = require('../unary-expression/parens');
 const {isCoupleLines} = require('../../is');
 const {isMarkedAfter} = require('../../mark');
+const {
+    maybePrintLeftBrace,
+    maybePrintRightBrace,
+} = require('./maybe-write-brace');
 
-module.exports.AssignmentExpression = {
-    condition: (path) => {
-        const {left} = path.node;
-        
-        if (isObjectPattern(left))
-            return true;
-        
-        if (isParens(path))
-            return true;
-        
-        return path.parentPath.isLogicalExpression();
-    },
-    before(path, {write}) {
-        write('(');
-    },
-    print(path, {print, maybe}) {
-        const {operator} = path.node;
-        maybe.print.breakline(isPrevCoupleLines(path));
-        
-        print('__left');
-        print.space();
-        print(operator);
-        print.space();
-        print('__right');
-    },
-    after(path, {write}) {
-        write(')');
-    },
+module.exports.AssignmentExpression = (path, printer, semantics) => {
+    const {print, maybe} = printer;
+    const {operator} = path.node;
+    
+    maybe.print.breakline(isPrevCoupleLines(path));
+    maybePrintLeftBrace(path, printer, semantics);
+    print('__left');
+    print.space();
+    print(operator);
+    print.space();
+    print('__right');
+    maybePrintRightBrace(path, printer, semantics);
 };
 
 const isPrevCoupleLines = ({parentPath}) => {

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

@@ -0,0 +1,40 @@
+'use strict';
+
+const {isParens} = require('../unary-expression/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 (!roundBraces)
+        return;
+    
+    if (!isParens(path))
+        return;
+    
+    write(brace);
+}

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

@@ -0,0 +1,35 @@
+'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}) {
+    const {parentPath} = path;
+    const {type} = parentPath;
+    const {roundBraces} = semantics;
+    const {write} = printer;
+    
+    if (type === 'ArrowFunctionExpression') {
+        write(brace);
+        return;
+    }
+    
+    if (type === 'LogicalExpression') {
+        write(brace);
+        return;
+    }
+    
+    if (!roundBraces)
+        return;
+    
+    write(brace);
+}

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

@@ -1,14 +1,17 @@
 'use strict';
 
+const {
+    maybeWriteLeftBrace,
+    maybeWriteRightBrace,
+} = require('./maybe-write-brace');
+
 module.exports.SequenceExpression = (path, printer, semantics) => {
     const {maybe, traverse} = printer;
     
     const expressions = path.get('expressions');
     const n = expressions.length - 1;
     
-    maybeWriteBrace(path, printer, semantics, {
-        brace: '(',
-    });
+    maybeWriteLeftBrace(path, printer, semantics);
     
     for (const [index, expression] of expressions.entries()) {
         traverse(expression);
@@ -16,27 +19,5 @@ module.exports.SequenceExpression = (path, printer, semantics) => {
         maybe.write.space(index < n);
     }
     
-    maybeWriteBrace(path, printer, semantics, {
-        brace: ')',
-    });
+    maybeWriteRightBrace(path, printer, semantics);
 };
-
-function maybeWriteBrace(path, printer, semantics, {brace}) {
-    const {roundBraces} = semantics;
-    const {write} = printer;
-    
-    if (path.parentPath.isArrowFunctionExpression()) {
-        write(brace);
-        return;
-    }
-    
-    if (path.parentPath.isLogicalExpression()) {
-        write(brace);
-        return;
-    }
-    
-    if (!roundBraces)
-        return;
-    
-    write(brace);
-}

package/package.json

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