@putout/printer 1.145.0 → 1.148.0

package/ChangeLog

@@ -1,3 +1,16 @@
+2023.06.08, v1.148.0
+
+fix:
+- 26795a8 @putout/printer: BinaryExpression: Strings
+
+feature:
+- 55cb78d @putout/printer: ArrayExpression: plugins
+
+2023.06.08, v1.146.0
+
+feature:
+- ab62be3 @putout/printer: ArrayExpression: Tuple: String and MemberExpression
+
 2023.06.08, v1.145.0
 
 feature:

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

@@ -11,6 +11,7 @@ const {
     isBooleanLiteral,
     isNullLiteral,
     isObjectExpression,
+    isAwaitExpression,
 } = require('@babel/types');
 
 const {isSimple} = require('@putout/operate');
@@ -19,7 +20,7 @@ const {
     isCoupleLines,
     isStringAndIdentifier,
     isIdentifierAndString,
-
+    isStringAndMember,
 } = require('../is');
 
 const isForOf = ({parentPath}) => parentPath.isForOfStatement();
@@ -28,7 +29,14 @@ const isStringAndArray = ([a, b]) => isStringLiteral(a) && isArrayExpression(b);
 const isStringAndString = ([a, b]) => isStringLiteral(a) && isStringLiteral(b);
 const isIdentifierAndIdentifier = ([a, b]) => isIdentifier(a) && isIdentifier(b);
 const isInsideArray = (path) => path.parentPath.isArrayExpression();
-const isSimpleAndCall = ([a, b]) => isSimple(a) && isCallExpression(b);
+
+const isSimpleAndCall = ([a, b]) => {
+    if (!isSimple(a))
+        return;
+    
+    return isCallExpression(b) || isAwaitExpression(b);
+};
+
 const isBooleanAndSimple = ([a, b]) => isBooleanLiteral(a) && isSimple(b);
 const isNullAndSimple = ([a, b]) => isNullLiteral(a) && isSimple(b);
 const isSimpleAndObject = ([a, b]) => isSimple(a) && isObjectExpression(b);
@@ -260,6 +268,9 @@ function isNewlineBetweenElements(path, {elements}) {
     if (isStringAndArray(elements))
         return false;
     
+    if (isStringAndMember(elements))
+        return false;
+    
     if (isStringAndIdentifier(elements))
         return false;
     

package/lib/tokenize/expressions/{binary-expression.js → binary-expression/binary-expression.js}

@@ -1,5 +1,10 @@
 'use strict';
 
+const {
+    concatanate,
+    isConcatenation,
+} = require('./concatanate');
+
 const BinaryExpression = {
     condition(path) {
         const parens = path.node.extra?.parenthesized;
@@ -12,26 +17,29 @@ const BinaryExpression = {
     before(path, {print}) {
         print('(');
     },
-    print(path, {write, traverse}) {
+    print(path, {print, indent, maybe}) {
         const {operator} = path.node;
-        const left = path.get('left');
-        const right = path.get('right');
         
         if (operator === 'instanceof') {
-            traverse(left);
-            write(' ');
-            write(operator);
-            write(' ');
-            traverse(right);
+            print('__left');
+            print(' instanceof ');
+            print('__right');
             
             return;
         }
         
-        traverse(left);
-        write.space();
-        write(path.node.operator);
-        write.space();
-        traverse(right);
+        if (isConcatenation(path))
+            return concatanate(path, {
+                print,
+                indent,
+                maybe,
+            });
+        
+        print('__left');
+        print.space();
+        print(path.node.operator);
+        print.space();
+        print('__right');
     },
     after(path, {print}) {
         print(')');

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

@@ -0,0 +1,56 @@
+'use strict';
+
+const {
+    isStringLiteral,
+    isTemplateLiteral,
+    isBinaryExpression,
+} = require('@babel/types');
+
+const isStringLike = (a) => {
+    if (isStringLiteral(a))
+        return true;
+    
+    if (isTemplateLiteral(a))
+        return true;
+    
+    return false;
+};
+
+module.exports.isConcatenation = (path) => {
+    const {parentPath} = path;
+    const {operator} = path.node;
+    
+    const startLine = path.node.loc?.start.line;
+    const endLine = path.node.loc?.end.line;
+    
+    if (startLine === endLine)
+        return false;
+    
+    const left = path.get('left');
+    const right = path.get('right');
+    
+    if (operator !== '+')
+        return false;
+    
+    if (isStringLike(left) && isStringLike(right) && isBinaryExpression(parentPath))
+        return true;
+    
+    return isBinaryExpression(left) && isStringLike(right);
+};
+
+module.exports.concatanate = (path, {print, indent}) => {
+    if (!path.parentPath.isBinaryExpression()) {
+        indent.inc();
+        print.breakline();
+    }
+    
+    print('__left');
+    print.space();
+    print('+');
+    print.breakline();
+    print('__right');
+    
+    if (!path.parentPath.isBinaryExpression()) {
+        indent.dec();
+    }
+};

package/lib/tokenize/expressions/index.js

@@ -17,11 +17,8 @@ const {
 
 const {NewExpression} = require('./new-expression');
 
-const {
-    ObjectExpression,
-    ObjectProperty,
-} = require('./object-expression');
-
+const {ObjectExpression} = require('./object-expression/object-expression');
+const {ObjectProperty} = require('./object-expression/object-property');
 const {ObjectPattern} = require('./object-pattern');
 
 const {
@@ -42,7 +39,7 @@ const {TaggedTemplateExpression} = require('./tagged-template-expression');
 const {
     BinaryExpression,
     LogicalExpression,
-} = require('./binary-expression');
+} = require('./binary-expression/binary-expression');
 
 const {ConditionalExpression} = require('./conditional-expression');
 

package/lib/tokenize/expressions/{object-expression.js → object-expression/object-expression.js}

@@ -9,9 +9,9 @@ const {
     noLeadingComment,
     hasLeadingComment,
     exists,
-} = require('../is');
+} = require('../../is');
 
-const {parseComments} = require('../comments');
+const {parseComments} = require('../../comments');
 
 const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
 const isLogical = (path) => path.get('argument').isLogicalExpression();
@@ -86,35 +86,10 @@ function shouldAddNewline(path) {
     return path.parentPath.parentPath.isSpreadElement();
 }
 
-module.exports.ObjectProperty = (path, {print, maybe}) => {
-    const {
-        shorthand,
-        computed,
-    } = path.node;
-    
-    const properties = path.parentPath.get('properties');
-    const isLast = path === properties.at(-1);
-    const manyLines = !isOneLine(path.parentPath);
-    
-    maybe.print(computed, '[');
-    print('__key');
-    maybe.print(computed, ']');
-    
-    if (!shorthand) {
-        print(':');
-        print.space();
-        print('__value');
-    }
-    
-    if (manyLines)
-        print(',');
-    else if (!isLast && properties.length)
-        print(', ');
-};
-
 const ONE_LINE = true;
 const MANY_LINES = false;
 
+module.exports.isOneLine = isOneLine;
 function isOneLine(path) {
     const {length} = path.get('properties');
     

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

@@ -0,0 +1,33 @@
+'use strict';
+
+const {isConcatenation} = require('../binary-expression/concatanate');
+const {isOneLine} = require('./object-expression');
+
+module.exports.ObjectProperty = (path, {maybe, traverse, write}) => {
+    const {
+        shorthand,
+        computed,
+    } = path.node;
+    
+    const key = path.get('key');
+    const value = path.get('value');
+    
+    const properties = path.parentPath.get('properties');
+    const isLast = path === properties.at(-1);
+    const manyLines = !isOneLine(path.parentPath);
+    
+    maybe.write(computed, '[');
+    traverse(key);
+    maybe.write(computed, ']');
+    
+    if (!shorthand) {
+        write(':');
+        maybe.write.space(!isConcatenation(value));
+        traverse(value);
+    }
+    
+    if (manyLines)
+        write(',');
+    else if (!isLast && properties.length)
+        write(', ');
+};

package/lib/tokenize/is.js

@@ -7,6 +7,7 @@ const {
     isStatement,
     isForOfStatement,
     isVariableDeclaration,
+    isMemberExpression,
 } = require('@babel/types');
 
 const isParentProgram = (path) => path.parentPath?.isProgram();
@@ -43,6 +44,7 @@ function isCoupleLines(path) {
 
 module.exports.exists = (a) => a.node;
 module.exports.isStringAndIdentifier = ([a, b]) => isStringLiteral(a) && isIdentifier(b);
+module.exports.isStringAndMember = ([a, b]) => isStringLiteral(a) && isMemberExpression(b);
 module.exports.isIdentifierAndString = ([a, b]) => isIdentifier(a) && isStringLiteral(b);
 
 const isIfOrStatement = (a) => isIfStatement(a) || isStatement(a);

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

@@ -12,6 +12,8 @@ const {hasPrevNewline} = require('../../mark');
 const {isExportDeclaration} = require('@babel/types');
 const {maybeSpaceAfterKeyword} = require('./maybe-space-after-keyword');
 
+const {isConcatenation} = require('../../expressions/binary-expression/concatanate');
+
 const isParentBlock = (path) => /Program|BlockStatement|Export/.test(path.parentPath.type);
 const isInsideBlock = (path) => /^(Program|BlockStatement)$/.test(path.parentPath.type);
 
@@ -40,7 +42,7 @@ module.exports.VariableDeclaration = {
             if (exists(init)) {
                 write.space();
                 write('=');
-                write.space();
+                maybe.write.space(!isConcatenation(init));
                 traverse(init);
             }
             

package/lib/tokenize/typescript/index.js

@@ -45,6 +45,9 @@ module.exports = {
     TSUnknownKeyword(path, {write}) {
         write('unknown');
     },
+    TSObjectKeyword(path, {write}) {
+        write('object');
+    },
     TSTupleType(path, {write, traverse, maybe}) {
         const elementTypes = path.get('elementTypes');
         const n = elementTypes.length - 1;

package/package.json

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