@putout/printer 1.74.0 → 1.76.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.04.28, v1.76.0
+
+feature:
+- a515fbc @putout/printer: improve support of newlines in with comments
+
+2023.04.27, v1.75.0
+
+feature:
+- 0560c33 @putout/printer: MemberExpression: simplify chain
+
 2023.04.26, v1.74.0
 
 feature:

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

@@ -22,8 +22,6 @@ const isStringAndString = ([a, b]) => isStringLiteral(a) && isStringLiteral(b);
 const isIdentifierAndIdentifier = ([a, b]) => isIdentifier(a) && isIdentifier(b);
 const isArrayParent = (path) => path.parentPath.isArrayExpression();
 
-const isTwoElementReturn = (path, {elements}) => path.parentPath.isReturnStatement() && elements.length === 2;
-
 const isTwoLongStrings = ([a, b]) => {
     const LONG_STRING = 20;
     
@@ -207,10 +205,10 @@ function isNewlineBetweenElements(path, {elements}) {
     if (isOneSimple(path))
         return false;
     
-    if (isCallInsideArrow(path))
+    if (elements.length === 2 && isIdentifierAndIdentifier(elements))
         return false;
     
-    if (isTwoElementReturn(path, {elements}))
+    if (isCallInsideArrow(path))
         return false;
     
     if (isOneElementCall(path, {elements}))

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

@@ -31,8 +31,7 @@ function CallExpression(path, {indent, print, maybe, traverse}) {
         const isObject = arg.isObjectExpression();
         
         if (isParentCall && !isObject && n) {
-            print.newline();
-            indent();
+            print.breakline();
         }
         
         print(arg);

package/lib/tokenize/expressions/chain/chain.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const {assign} = Object;
+
+module.exports.chain = (path) => {
+    const all = [
+        ...down(path),
+        ...up(path),
+    ];
+    
+    const properties = all.slice(0, -1);
+    const root = all.at(-1);
+    
+    return [root, properties];
+};
+
+function down(path) {
+    const properties = [];
+    
+    let current = path.get('object');
+    
+    while (!current.isIdentifier()) {
+        const isFn = current.isCallExpression();
+        const prop = build(current);
+        
+        if (isFn)
+            current = current.get('callee');
+        
+        properties.unshift(prop);
+        
+        if (!current.isMemberExpression())
+            break;
+        
+        current = current.get('object');
+    }
+    
+    return properties;
+}
+
+function up(current) {
+    const properties = [];
+    
+    while (current.isMemberExpression()) {
+        current = current.parentPath;
+        
+        if (current.isCallExpression()) {
+            properties.push(build(current));
+            current = current.parentPath;
+        }
+        
+        if (!current.isMemberExpression())
+            break;
+    }
+    
+    properties.push({
+        type: current.type,
+    });
+    
+    return properties;
+}
+
+function build(path) {
+    const prop = {
+        type: path.type,
+    };
+    
+    if (path.isCallExpression()) {
+        assign(prop, {
+            args: path.node.arguments.length,
+            name: path.node.callee.property?.name || '',
+        });
+    }
+    
+    return prop;
+}

package/lib/tokenize/expressions/class.js

@@ -31,7 +31,9 @@ function classVisitor(path, {print, indent, maybe}) {
     
     if (node.implements) {
         print(' implements ');
-        path.get('implements').forEach(print);
+        path
+            .get('implements')
+            .forEach(print);
     }
     
     if (node.superClass) {

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

@@ -1,18 +1,14 @@
 'use strict';
 
 const {
-    isIfStatement,
-    isIdentifier,
-    isThisExpression,
     isUnaryExpression,
+    isArrowFunctionExpression,
+    isLogicalExpression,
 } = require('@babel/types');
 
-const {
-    compare,
-    getTemplateValues,
-} = require('@putout/compare');
+const {chain} = require('./chain/chain');
 
-module.exports.MemberExpression = (path, {print, indent, maybe, traverse}) => {
+module.exports.MemberExpression = (path, {print, maybe, traverse}) => {
     const {computed} = path.node;
     const object = path.get('object');
     const isObjectAwait = object.isAwaitExpression();
@@ -29,12 +25,12 @@ module.exports.MemberExpression = (path, {print, indent, maybe, traverse}) => {
         return;
     }
     
-    const isChain = isLooksLikeChain(path);
+    const isChain = likeChain(path);
+    
     maybe.indent.inc(isChain);
     
     if (isChain) {
-        print.newline();
-        indent(isChain);
+        print.breakline();
     }
     
     print('.');
@@ -58,66 +54,25 @@ module.exports.OptionalMemberExpression = (path, {print}) => {
     print('__property');
 };
 
-function isLooksLikeChain(path) {
-    const {parentPath} = path;
-    
-    if (path.find(isIfStatement))
-        return false;
-    
-    if (compare(parentPath.parentPath.parentPath, '__a.__b(__x).__c(__y)'))
-        return true;
-    
-    if (compare(parentPath, '__a.__b(__x).__c(__y)'))
-        return true;
-    
-    if (path.find(isUnaryExpression))
-        return false;
-    
-    const isMember = ({parentPath}) => parentPath.parentPath.isMemberExpression();
-    const isExpression = ({parentPath}) => parentPath.parentPath.isExpressionStatement();
-    const itMember = isMember(path);
-    const itExpression = isExpression(path);
-    const callee = parentPath.get('callee');
-    
-    if (parentPath.isLiteral())
-        return false;
-    
-    if (!itMember && !path.parentPath.isExpressionStatement() && !parentPath.isCallExpression())
-        return false;
-    
-    if (!parentPath.isCallExpression())
-        return false;
-    
-    if (callee !== path)
-        return false;
-    
-    if (compare(path.parentPath, '__a.__b(__args)[__c]'))
-        return false;
-    
-    if (compare(path.parentPath.parentPath, '__a.__b().__c()'))
-        return false;
-    
-    if (compare(path.parentPath.parentPath, '(__args) => __b.__c(__args).__d()'))
-        return false;
+const isCall = (a) => a.type === 'CallExpression';
+
+function likeChain(path) {
+    const [root, properties] = chain(path);
     
-    if (compare(parentPath, '__a.__b.__c(__args)') && !itMember)
+    if (isUnaryExpression(root))
         return false;
     
-    if (compare(parentPath, '__a.__b.__c = __d'))
+    if (isArrowFunctionExpression(root))
         return false;
     
-    if (compare(parentPath, '(__args) => __a.__b(__args).__c'))
+    if (isLogicalExpression(root))
         return false;
     
-    const {__a, __b} = getTemplateValues(parentPath, '__a.__b(__args)');
-    const aType = __a?.type;
-    const bType = __b?.type;
-    
-    if (aType === bType && isIdentifier(__a) && itExpression)
-        return false;
+    const calls = properties.filter(isCall);
+    const [firstCall] = calls;
     
-    if (isThisExpression(__a) && isIdentifier(__b) && itExpression)
+    if (calls.length === 2 && !firstCall.name)
         return false;
     
-    return itExpression;
+    return calls.length > 1;
 }

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

@@ -7,7 +7,8 @@ const {
     noTrailingComment,
     isNewlineBetweenSiblings,
     noLeadingComment,
-    noComment,
+    hasLeadingComment,
+    exists,
 } = require('../is');
 
 const {isFunction} = require('@babel/types');
@@ -52,8 +53,11 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
         }
         
         print(property);
-        maybe.print.newline(manyLines && noTrailingComment(property) && noComment(property));
-        maybe.print.linebreak(isNewlineBetweenSiblings(property));
+        
+        if (!hasNextLeadingComment(property)) {
+            maybe.print.newline(manyLines && noTrailingComment(property));
+            maybe.print.linebreak(isNewlineBetweenSiblings(property));
+        }
     }
     
     indent.dec();
@@ -63,6 +67,15 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
     maybe.print(parens, ')');
 };
 
+const hasNextLeadingComment = (path) => {
+    const next = path.getNextSibling();
+    
+    if (!exists(next))
+        return false;
+    
+    return hasLeadingComment(next);
+};
+
 function shouldAddNewline(path) {
     if (!path.parentPath.isLogicalExpression())
         return false;

package/lib/tokenize/is.js

@@ -85,7 +85,7 @@ module.exports.satisfy = (conditions) => (path) => {
 };
 
 module.exports.hasTrailingComment = (path) => path.node?.trailingComments?.length;
+module.exports.hasLeadingComment = (path) => path.node?.leadingComments?.length;
 
 module.exports.noTrailingComment = (path) => !path.node.trailingComments?.length;
-module.exports.noComment = (path) => !path.node.comments?.length;
 module.exports.noLeadingComment = (path) => !path.node.leadingComments?.length;

package/lib/tokenize/jsx/jsx-attribute.js

@@ -21,4 +21,3 @@ module.exports.JSXAttribute = {
         indent.dec();
     },
 };
-

package/lib/tokenize/jsx/jsx-text.js

@@ -9,16 +9,14 @@ module.exports.JSXText = (path, {write, indent}) => {
     
     if (isSpacesOnly && hasNext) {
         indent.inc();
-        write.newline();
-        write.indent();
+        write.breakline();
         indent.dec();
         
         return;
     }
     
     if (isSpacesOnly) {
-        write.newline();
-        write.indent();
+        write.breakline();
         
         return;
     }

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

@@ -9,12 +9,30 @@ const {
     satisfy,
     noTrailingComment,
     hasTrailingComment,
+    exists,
 } = require('../is');
 
+const satisfyAfter = satisfy([
+    isParentBlockOrNotLastOrParentLast,
+    isParentBlock,
+    isNext,
+    isNextUp,
+]);
+
 const isNextLiteral = (path) => {
     const next = path.getNextSibling();
+    
+    if (!exists(next))
+        return false;
+    
     const expression = next.get('expression');
     
+    if (expression.isTemplateLiteral())
+        return true;
+    
+    if (expression.isArrayExpression())
+        return true;
+    
     return expression.isLiteral();
 };
 
@@ -36,15 +54,22 @@ module.exports.ExpressionStatement = {
             store(true);
         }
     },
-    afterSatisfy: () => [
-        isParentBlockOrNotLastOrParentLast,
-        isParentBlock,
-        isNext,
-        isNextUp,
-    ],
-    after(path, {print, maybe, store}) {
+    afterIf: (path) => {
         if (hasTrailingComment(path) && isNextLiteral(path))
-            return;
+            return false;
+        
+        if (satisfyAfter(path))
+            return true;
+        
+        if (hasTrailingComment(path) && isLast(path))
+            return true;
+        
+        return false;
+    },
+    after(path, {print, maybe, store}) {
+        if (hasTrailingComment(path) && isLast(path)) {
+            print.breakline();
+        }
         
         print.newline();
         maybe.markAfter(store(), path);

package/lib/tokenize/statements/for-in-statement.js

@@ -8,7 +8,9 @@ module.exports.ForInStatement = (path, {print}) => {
     print('__right');
     print(')');
     
-    if (path.get('body').isBlockStatement())
+    if (path
+        .get('body')
+        .isBlockStatement())
         print.space();
     
     print('__body');

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

@@ -64,7 +64,9 @@ module.exports.ImportDeclaration = {
         if (isLast(path))
             return false;
         
-        if (path.getNextSibling().isImportDeclaration())
+        if (path
+            .getNextSibling()
+            .isImportDeclaration())
             return false;
         
         return true;

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

@@ -20,7 +20,9 @@ module.exports.SwitchStatement = {
             print(switchCase.get('test'));
             print(':');
             
-            const isBlock = switchCase.get('consequent.0').isBlockStatement();
+            const isBlock = switchCase
+                .get('consequent.0')
+                .isBlockStatement();
             
             maybe.indent.inc(!isBlock);
             maybe.print.newline(!isBlock);

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

@@ -125,5 +125,7 @@ const isNextAssign = (path) => {
     if (parentPath.isBlockStatement() && parentPath.node.body.length < 3)
         return false;
     
-    return nextPath.get('expression').isAssignmentExpression();
+    return nextPath
+        .get('expression')
+        .isAssignmentExpression();
 };

package/package.json

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