@putout/printer 11.2.1 → 11.4.0

package/ChangeLog

@@ -1,3 +1,15 @@
+2024.12.13, v11.4.0
+
+feature:
+- 332efd1 @putout/printer: LogicalExpression inside UnaryExpression: parens
+
+2024.12.12, v11.3.0
+
+feature:
+- b5de5fc @putout/printer: split BinaryExpression and LogicalExpression
+- 262f6ab @putout/printer: LogicalExpressions: maxElementsInOneLine
+- 4bccded @putout/printer: LogicalExpressions: newline
+
 2024.12.12, v11.2.1
 
 feature:

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const {isParens} = require('../../maybe/maybe-parens');
+
 module.exports.maybePrintLeftBrace = (path, printer, semantics) => {
     maybeWriteBrace(path, printer, semantics, {
         brace: '(',

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

@@ -6,56 +6,33 @@ const {
 } = require('./concatenate');
 
 const {maybeSpace} = require('./maybe-space');
-const {isParens} = require('../../maybe/maybe-parens');
+const {maybeParens} = require('../../maybe/maybe-parens');
 
-const BinaryExpression = {
-    condition(path) {
-        if (isParens(path))
-            return true;
-        
-        return path.parentPath.isAwaitExpression();
-    },
-    before(path, {print}) {
-        print('(');
-    },
-    print(path, {print, indent, maybe}) {
-        const {operator} = path.node;
-        
-        if (operator === 'instanceof') {
-            print('__left');
-            print(' instanceof ');
-            print('__right');
-            
-            return;
-        }
-        
-        if (operator === 'in') {
-            print('__left');
-            print(' in ');
-            print('__right');
-            
-            return;
-        }
-        
-        if (isConcatenation(path))
-            return concatenate(path, {
-                print,
-                indent,
-                maybe,
-            });
-        
+module.exports.BinaryExpression = maybeParens((path, {print, indent, maybe}) => {
+    const {operator} = path.node;
+    
+    if (operator === 'in' || operator === 'instanceof') {
         print('__left');
-        print.space();
-        print(path.node.operator);
-        maybeSpace(path, {
+        print(' ');
+        print(operator);
+        print(' ');
+        print('__right');
+        
+        return;
+    }
+    
+    if (isConcatenation(path))
+        return concatenate(path, {
             print,
+            indent,
+            maybe,
         });
-        print('__right');
-    },
-    after(path, {print}) {
-        print(')');
-    },
-};
-
-module.exports.BinaryExpression = BinaryExpression;
-module.exports.LogicalExpression = BinaryExpression;
+    
+    print('__left');
+    print.space();
+    print(path.node.operator);
+    maybeSpace(path, {
+        print,
+    });
+    print('__right');
+});

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

@@ -17,6 +17,9 @@ module.exports.isConcatenation = (path) => {
     const {parentPath} = path;
     const {operator} = path.node;
     
+    if (operator !== '+')
+        return false;
+    
     const startLine = path.node.loc?.start.line;
     const endLine = path.node.loc?.end.line;
     
@@ -26,9 +29,6 @@ module.exports.isConcatenation = (path) => {
     const left = path.get('left');
     const right = path.get('right');
     
-    if (operator !== '+')
-        return false;
-    
     if (isStringLike(left) && isStringLike(right) && isBinaryExpression(parentPath))
         return true;
     

package/lib/tokenize/expressions/index.js

@@ -35,12 +35,8 @@ const {RestElement} = require('./rest-element');
 const {SpreadElement} = require('./spread-element');
 const {SequenceExpression} = require('./sequence-expression/sequence-expression');
 const {TaggedTemplateExpression} = require('./tagged-template-expression');
-
-const {
-    BinaryExpression,
-    LogicalExpression,
-} = require('./binary-expression/binary-expression');
-
+const {BinaryExpression} = require('./binary-expression/binary-expression');
+const {LogicalExpression} = require('./logical-expression/logical-expression');
 const {ConditionalExpression} = require('./conditional-expression');
 const {StaticBlock} = require('./class/static-block');
 const {RecordExpression} = require('./object-expression/record-expression');

package/lib/tokenize/expressions/logical-expression/chain.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const {
+    isReturnStatement,
+    isVariableDeclarator,
+} = require('@putout/babel').types;
+
+module.exports.isRootOk = (path) => {
+    return isReturnStatement(path) || isVariableDeclarator(path);
+};
+
+module.exports.chain = (path) => {
+    const [downCount] = down(path);
+    const [upCount, root] = up(path);
+    
+    return [
+        root,
+        downCount + upCount,
+        downCount,
+        upCount,
+    ];
+};
+
+function down(current) {
+    let count = 0;
+    
+    do {
+        ++count;
+        current = current.get('left');
+        const {operator} = current.node;
+        
+        if (operator !== '||' && operator !== '&&')
+            break;
+    } while (current.isLogicalExpression());
+    
+    return [count];
+}
+
+function up(current) {
+    let count = 0;
+    
+    do {
+        ++count;
+        current = current.parentPath;
+    } while (current.isLogicalExpression());
+    
+    return [
+        count, {
+            type: current.type,
+        },
+    ];
+}

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

@@ -0,0 +1,40 @@
+'use strict';
+
+const {maybeParens} = require('../../maybe/maybe-parens');
+const {chain, isRootOk} = require('./chain');
+
+module.exports.LogicalExpression = maybeParens({
+    condition(path) {
+        if (path.parentPath.isUnaryExpression())
+            return true;
+        
+        return path.parentPath.isAwaitExpression();
+    },
+    print(path, {print, maybe}, semantics) {
+        print('__left');
+        
+        const needNewLine = isNewLine(path, semantics);
+        
+        maybe.indent.inc(needNewLine);
+        needNewLine ? print.breakline() : print.space();
+        maybe.indent.dec(needNewLine);
+        
+        print(path.node.operator);
+        print.space();
+        print('__right');
+    },
+});
+
+function isNewLine(path, semantics) {
+    const [root, count] = chain(path);
+    
+    if (!isRootOk(root))
+        return false;
+    
+    if (count <= semantics.maxElementsInOneLine)
+        return false;
+    
+    const {operator} = path.node;
+    
+    return operator === '||' || operator === '&&';
+}

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

@@ -1,9 +1,17 @@
 'use strict';
 
+const isFn = (a) => typeof a === 'function';
 const isParens = (path) => path.node.extra?.parenthesized;
 
 module.exports.isParens = isParens;
-module.exports.maybeParens = (print) => ({
+module.exports.maybeParens = (print) => {
+    if (isFn(print))
+        return maybeParensPrint(print);
+    
+    return maybeParensCondition(print);
+};
+
+const maybeParensPrint = (print) => ({
     condition: isParens,
     before(path, {write}) {
         write('(');
@@ -13,3 +21,8 @@ module.exports.maybeParens = (print) => ({
         write(')');
     },
 });
+
+const maybeParensCondition = ({print, condition}) => ({
+    ...maybeParensPrint(print),
+    condition: (path) => condition(path) || isParens(path),
+});

package/package.json

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