@putout/printer 1.16.2 → 1.17.1

package/ChangeLog

@@ -1,3 +1,15 @@
+2023.04.01, v1.17.1
+
+feature:
+- 794186f @putout/printer: improve support of IfElse
+- a35e751 @putout/printer: improve support of round braces
+
+2023.04.01, v1.17.0
+
+feature:
+- 1378835 @putout/printer: improve support of round brackets around LogicalExpressions
+- 3fc47f2 @putout/printer: improve support of BinaryExpression inside UnaryExpression
+
 2023.04.01, v1.16.2
 
 feature:

package/README.md

@@ -64,6 +64,23 @@ print(ast, {
 'const {a /* [hello world] */= 5} = b;\n';
 ```
 
+## Maybe
+
+When you need some condition use `maybe`. For example, to add newline only when parent node is `CallExpression` you
+can use `maybe.print.newline(condition)`:
+
+```js
+print(ast, {
+    visitors: {
+        AssignmentPattern(path, {print, maybe}) {
+            maybe.print.newline(path.parentPath.isCallExpression());
+            print(' /* [hello world] */= ');
+            print('__right');
+        },
+    },
+});
+```
+
 ## License
 
 MIT

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

@@ -3,13 +3,20 @@
 module.exports.BinaryExpression = BinaryExpression;
 module.exports.LogicalExpression = BinaryExpression;
 
-const isLogical = (path) => path.isLogicalExpression();
+const isLogical = (main, path) => {
+    const is = path.isLogicalExpression();
+    
+    if (!is)
+        return false;
+    
+    return main.node.operator !== path.node.operator;
+};
 
 function BinaryExpression(path, {write, traverse, maybe}) {
     const left = path.get('left');
     const right = path.get('right');
-    const isLeft = isLogical(left);
-    const isRight = isLogical(right);
+    const isLeft = isLogical(path, left);
+    const isRight = isLogical(path, right);
     
     maybe.write(isLeft, '(');
     traverse(left);

package/lib/tokenize/expressions/unary-expressions.js

@@ -32,21 +32,20 @@ function printUnary(path, name, {print}) {
 }
 const isWord = (a) => /delete|typeof/.test(a);
 
-function unaryExpression(path, {print, maybe}) {
+function unaryExpression(path, {maybe, traverse}) {
     const {
         prefix,
         operator,
     } = path.node;
     
-    if (prefix)
-        print(operator);
+    const argPath = path.get('argument');
+    const round = argPath.isBinaryExpression() || argPath.isLogicalExpression();
     
-    maybe.print(isWord(
-        operator,
-    ), ' ');
-    
-    print('__argument');
+    maybe.print(prefix, operator);
+    maybe.print(isWord(operator), ' ');
     
-    if (!prefix)
-        print(operator);
+    maybe.print(round, '(');
+    traverse(argPath);
+    maybe.print(round, ')');
+    maybe.print(!prefix, operator);
 }

package/lib/tokenize/is.js

@@ -15,7 +15,7 @@ const isNext = (path) => {
 const isNextParent = (path) => isNext(path.parentPath);
 const isLast = (path) => isParentProgram(path) && !isNext(path);
 
-module.exports.isFirst = (path) => path.node === path.parentPath.node.body[0];
+module.exports.isFirst = (path) => path.node === path.parentPath.node.body?.[0];
 module.exports.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
 module.exports.isNext = isNext;
 module.exports.isNextParent = isNextParent;

package/lib/tokenize/statements/if-statement.js

@@ -1,8 +1,11 @@
 'use strict';
 
-const {hasPrevNewline, markAfter} = require('../mark');
-const {isFirst} = require('../is');
+const {
+    hasPrevNewline,
+    markAfter,
+} = require('../mark');
 
+const {isFirst} = require('../is');
 const isEmptyConsequent = (path) => path.get('consequent').isEmptyStatement();
 
 module.exports.IfStatement = {
@@ -10,7 +13,7 @@ module.exports.IfStatement = {
         print.linebreak();
     },
     beforeIf: shouldAddNewlineBefore,
-    print: (path, {indent, print, maybe}) => {
+    print: (path, {indent, print, maybe, write, traverse}) => {
         indent();
         print('if (');
         print('__test');
@@ -24,7 +27,6 @@ module.exports.IfStatement = {
             print(consequent);
         } else {
             const is = !isEmptyConsequent(path);
-            
             maybe.print.newline(is);
             maybe.indent.inc(is);
             print(consequent);
@@ -32,21 +34,34 @@ module.exports.IfStatement = {
         }
         
         if (alternate.isBlockStatement()) {
-            print(' else ');
-            print(alternate);
+            write(' else ');
+            traverse(alternate);
+        } else if (alternate.isIfStatement()) {
+            print.space();
+            write('else');
+            print.space();
+            traverse(alternate);
         } else if (alternate.node) {
             print.breakline();
-            print('else');
+            write('else');
             print.newline();
             indent.inc();
-            print(alternate);
+            traverse(alternate);
             indent.dec();
         }
+        
+        const next = path.getNextSibling();
+        
+        if (next.isExpressionStatement() && !next.get('expression').isCallExpression())
+            print.newline();
     },
     afterIf: (path) => {
         const next = path.getNextSibling();
         
-        if (!next.node || next.isExpressionStatement() || next.isReturnStatement())
+        if (!next.node)
+            return false;
+        
+        if (next.isReturnStatement())
             return false;
         
         return true;
@@ -59,5 +74,8 @@ module.exports.IfStatement = {
 };
 
 function shouldAddNewlineBefore(path) {
+    if (path.parentPath.isIfStatement())
+        return false;
+    
     return !isFirst(path) && !hasPrevNewline(path);
 }

package/lib/tokenize/tokenize.js

@@ -78,6 +78,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
     const maybeBreakline = (a) => a && breakline();
     const maybeLinebreak = (a) => a && linebreak();
     const maybeWrite = (a, b) => a && write(b);
+    const maybeSpace = (a) => a && space();
     let i = 0;
     const incIndent = () => ++i;
     const decIndent = () => --i;
@@ -135,6 +136,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
         markBefore: maybeMarkBefore,
         markAfter: maybeMarkAfter,
         write: maybeWrite,
+        space: maybeSpace,
     };
     
     assign(maybe.indent, {
@@ -190,6 +192,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
             newline: maybeNewline,
             breakline: maybeBreakline,
             linebreak: maybeLinebreak,
+            space: maybeSpace,
         });
         
         assign(printer.maybe, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.16.2",
+  "version": "1.17.1",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Easiest possible opinionated Babel AST printer made with ❤️  to use in 🐊Putout",