@putout/printer 1.73.2 → 1.75.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.04.27, v1.75.0
+
+feature:
+- 0560c33 @putout/printer: MemberExpression: simplify chain
+
+2023.04.26, v1.74.0
+
+feature:
+- 9ef7aaa @putout/printer: add support of empty value in JSXAttribute
+
 2023.04.26, v1.73.2
 
 feature:

package/README.md

@@ -51,7 +51,6 @@ const {parse} = require('@babel/parser');
 const ast = parse('const a = (b, c) => {const d = 5; return a;}');
 
 print(ast);
-
 // returns
 `
 const a = (b, c) => {
@@ -87,7 +86,6 @@ print(ast, {
         },
     },
 });
-
 // returns
 'const {a /* [hello world] */= 5} = b;\n';
 ```

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/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/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/jsx/jsx-attribute.js

@@ -10,9 +10,11 @@ module.exports.JSXAttribute = {
         indent.inc();
         print.breakline();
     },
-    print(path, {print}) {
+    print(path, {print, maybe}) {
+        const {value} = path.node;
+        
         print('__name');
-        print('=');
+        maybe.print(value, '=');
         print('__value');
     },
     after(path, {indent}) {

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

@@ -15,6 +15,9 @@ const isNextLiteral = (path) => {
     const next = path.getNextSibling();
     const expression = next.get('expression');
     
+    if (expression.isTemplateLiteral())
+        return true;
+    
     return expression.isLiteral();
 };
 

package/package.json

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