@putout/printer 1.16.1 → 1.17.0

package/ChangeLog

@@ -1,3 +1,14 @@
+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:
+- 6da9571 @putout/printer: improve support of ObjectExpression used as argument of CallExpression
+
 2023.04.01, v1.16.1
 
 feature:

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/call-expression.js

@@ -27,7 +27,9 @@ const CallExpression = {
         maybe.indent.inc(isParentCall);
         
         for (const [i, arg] of args.entries()) {
-            if (isParentCall) {
+            const isObject = arg.isObjectExpression();
+            
+            if (isParentCall && !isObject) {
                 print.newline();
                 indent();
             }
@@ -80,7 +82,7 @@ function toLong(path) {
     const args = path.get('arguments');
     
     for (const arg of args) {
-        if (arg.isIdentifier() && arg.node.name.length > 5)
+        if (arg.isIdentifier() && arg.node.name.length > 10)
             return true;
     }
     

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

@@ -3,6 +3,8 @@
 const {isCoupleLines} = require('../is');
 const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
 const isLogical = (path) => path.get('argument').isLogicalExpression();
+const isValue = (path) => path.get('properties.0.value').node;
+const isIf = (path) => path.parentPath.parentPath.isIfStatement();
 
 const isForOf = (path) => {
     if (path.parentPath.isForOfStatement())
@@ -74,18 +76,23 @@ module.exports.ObjectProperty = (path, {print, maybe}) => {
     maybe.print(manyLines, ',');
 };
 
+const ONE_LINE = true;
+const MANY_LINES = false;
+
 function isOneLine(path) {
-    const isCall = path.parentPath.isCallExpression();
     const {length} = path.get('properties');
     
     if (!length)
         return true;
     
-    if (isCoupleLines(path))
-        return false;
+    if (isForOf(path))
+        return ONE_LINE;
     
-    if (isCall && length < 2)
-        return true;
+    if (isIf(path))
+        return ONE_LINE;
+    
+    if (isCoupleLines(path))
+        return MANY_LINES;
     
-    return isForOf(path);
+    return !isValue(path);
 }

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

@@ -32,21 +32,21 @@ 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();
     
-    maybe.print(isWord(
-        operator,
-    ), ' ');
+    maybe.print(prefix, operator);
     
-    print('__argument');
+    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

@@ -59,5 +59,8 @@ module.exports.IfStatement = {
 };
 
 function shouldAddNewlineBefore(path) {
+    if (path.parentPath.isIfStatement())
+        return false;
+    
     return !isFirst(path) && !hasPrevNewline(path);
 }

package/lib/tokenize/statements/variable-declaration.js

@@ -12,32 +12,38 @@ const {
 
 const isParentBlock = (path) => /Program|BlockStatement/.test(path.parentPath.type);
 
-module.exports.VariableDeclaration = (path, {maybe, print}) => {
-    if (shouldAddNewlineBefore(path))
+module.exports.VariableDeclaration = {
+    beforeIf: shouldAddNewlineBefore,
+    before(path, {print}) {
         print.breakline();
-    
-    maybe.indent(isParentBlock(path));
-    print(`${path.node.kind} `);
-    print('__declarations.0.id');
-    
-    const initPath = path.get('declarations.0.init');
-    
-    maybe.print(initPath.node, ' = ');
-    print(initPath);
-    maybe.print(isParentBlock(path), ';');
-    
-    let wasNewline = false;
-    
-    if (isParentBlock(path) && isNext(path)) {
-        print.newline();
-        wasNewline = true;
-    }
-    
-    if (shouldAddNewlineAfter(path)) {
+    },
+    print(path, {maybe, print, store}) {
+        maybe.indent(isParentBlock(path));
+        print(`${path.node.kind} `);
+        print('__declarations.0.id');
+        
+        const initPath = path.get('declarations.0.init');
+        
+        maybe.print(initPath.node, ' = ');
+        print(initPath);
+        maybe.print(isParentBlock(path), ';');
+        
+        let wasNewline = false;
+        
+        if (isParentBlock(path) && isNext(path)) {
+            print.newline();
+            wasNewline = true;
+        }
+        
+        store(wasNewline);
+    },
+    afterIf: shouldAddNewlineAfter,
+    after(path, {maybe, store}) {
+        const wasNewline = store();
         maybe.print.linebreak(wasNewline);
         maybe.print.newline(!wasNewline);
         markAfter(path);
-    }
+    },
 };
 
 function shouldAddNewlineAfter(path) {
@@ -53,7 +59,9 @@ function shouldAddNewlineAfter(path) {
     if (isNextAssign(path))
         return true;
     
-    if (isCoupleLines(path.getNextSibling()))
+    const next = path.getNextSibling();
+    
+    if (isCoupleLines(next))
         return true;
     
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.16.1",
+  "version": "1.17.0",
   "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",
@@ -44,6 +44,7 @@
   ],
   "devDependencies": {
     "@putout/test": "^6.0.1",
+    "acorn": "^8.8.2",
     "c8": "^7.5.0",
     "eslint": "^8.0.1",
     "eslint-plugin-n": "^15.2.4",
@@ -55,9 +56,9 @@
     "montag": "^1.0.0",
     "nodemon": "^2.0.1",
     "putout": "*",
+    "putout-plugin-apply-computed-print": "./rules/putout-plugin-apply-computed-print",
     "supertape": "^8.0.0",
-    "try-catch": "^3.0.0",
-    "putout-plugin-apply-computed-print": "./rules/putout-plugin-apply-computed-print"
+    "try-catch": "^3.0.0"
   },
   "license": "MIT",
   "engines": {