@putout/printer 11.2.0 → 11.3.0

package/ChangeLog

@@ -1,3 +1,15 @@
+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:
+- 56da95d @putout/printer: maybeParens
+
 2024.12.12, v11.2.0
 
 feature:

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

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

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

@@ -6,56 +6,33 @@ const {
 } = require('./concatenate');
 
 const {maybeSpace} = require('./maybe-space');
-const {isParens} = require('../unary-expression/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/conditional-expression.js

@@ -1,24 +1,15 @@
 'use strict';
 
-const {isParens} = require('./unary-expression/parens');
+const {maybeParens} = require('../maybe/maybe-parens');
 
-module.exports.ConditionalExpression = {
-    condition: isParens,
-    before(path, {print}) {
-        print('(');
-    },
-    print(path, {print}) {
-        print('__test');
-        print.space();
-        print('?');
-        print.space();
-        print('__consequent');
-        print.space();
-        print(':');
-        print.space();
-        print('__alternate');
-    },
-    after(path, {print}) {
-        print(')');
-    },
-};
+module.exports.ConditionalExpression = maybeParens((path, {print}) => {
+    print('__test');
+    print.space();
+    print('?');
+    print.space();
+    print('__consequent');
+    print.space();
+    print(':');
+    print.space();
+    print('__alternate');
+});

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,46 @@
+'use strict';
+
+const {isParens} = require('../../maybe/maybe-parens');
+const {chain, isRootOk} = require('./chain');
+
+module.exports.LogicalExpression = {
+    condition(path) {
+        if (isParens(path))
+            return true;
+        
+        return path.parentPath.isAwaitExpression();
+    },
+    before(path, {print}) {
+        print('(');
+    },
+    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');
+    },
+    after(path, {print}) {
+        print(')');
+    },
+};
+
+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,10 @@
 'use strict';
 
+const isParens = (path) => path.node.extra?.parenthesized;
+
+module.exports.isParens = isParens;
 module.exports.maybeParens = (print) => ({
-    condition(path) {
-        return path.node.extra?.parenthesized;
-    },
+    condition: isParens,
     before(path, {write}) {
         write('(');
     },

package/lib/tokenize/typescript/ts-union-type/ts-union-type.js

@@ -1,25 +1,17 @@
 'use strict';
 
-const {
-    maybeParenOpen,
-    maybeParenClose,
-} = require('../../expressions/unary-expression/parens');
-
+const {maybeParens} = require('../../maybe/maybe-parens');
 const insideTypeDeclaration = ({parentPath}) => parentPath.isTSTypeAliasDeclaration();
 
-module.exports.TSUnionType = (path, printer, {maxTypesInOneLine}) => {
+module.exports.TSUnionType = maybeParens((path, printer, {maxTypesInOneLine}) => {
     const types = path.get('types');
     const {length} = types;
     
-    maybeParenOpen(path, printer);
-    
     if (!insideTypeDeclaration(path) || length <= maxTypesInOneLine)
         printInOneLine(types, printer);
     else
         printInCoupleLines(types, printer);
-    
-    maybeParenClose(path, printer);
-};
+});
 
 function printInOneLine(types, {traverse, write}) {
     const n = types.length - 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "11.2.0",
+  "version": "11.3.0",
   "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/unary-expression/parens.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const isParens = (path) => path.node.extra?.parenthesized;
-
-module.exports.isParens = isParens;
-
-module.exports.maybeParenOpen = (path, {maybe}) => {
-    maybe.write(isParens(path), '(');
-};
-
-module.exports.maybeParenClose = (path, {maybe}) => {
-    maybe.write(isParens(path), ')');
-};