@putout/printer 12.8.0 → 12.10.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2025.01.23, v12.10.0
+
+feature:
+- 262925b @putout/printer: BlockStatement: call inside chain
+
+2025.01.23, v12.9.0
+
+feature:
+- 750b6cd @putout/printer: NewExpression: round braces (coderiaser/minify#135)
+
 2025.01.22, v12.8.0
 
 feature:

package/lib/tokenize/expressions/member-expression/is-looks-like-chain.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const {types} = require('@putout/babel');
+const {chain} = require('./chain');
+const {satisfy} = require('../../is');
+
+const {
+    isUnaryExpression,
+    isIfStatement,
+    isCallExpression,
+} = types;
+
+const isArgOfCall = (path) => path.parentPath.isCallExpression() && path.parentPath.get('arguments.0') === path;
+const isCall = (a) => a.type === 'CallExpression';
+
+const isExcludedFromChain = satisfy([isUnaryExpression, isIfStatement]);
+
+module.exports.isLooksLikeChain = (path) => {
+    const [root, properties] = chain(path);
+    
+    if (isExcludedFromChain(root))
+        return false;
+    
+    if (properties.find(isPathGet))
+        return false;
+    
+    if (path.find(isIfUp))
+        return false;
+    
+    const calls = properties.filter(isCall);
+    const [firstCall] = calls;
+    
+    if (calls.length === 2 && !firstCall.name)
+        return false;
+    
+    if (isArgOfCall(path))
+        return false;
+    
+    return calls.length > 1;
+};
+
+const isPathGet = (property) => {
+    return isCallExpression(property, {
+        name: 'get',
+    });
+};
+
+const isIfUp = (path) => {
+    const ifPath = path.find(isIfStatement);
+    let is = false;
+    
+    if (!ifPath)
+        return is;
+    
+    ifPath.get('test').traverse({
+        MemberExpression(currentPath) {
+            if (path === currentPath) {
+                is = true;
+                path.stop();
+            }
+        },
+    });
+    
+    return is;
+};

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

@@ -1,20 +1,8 @@
 'use strict';
 
-const {types} = require('@putout/babel');
-
-const {chain} = require('./chain');
-const {satisfy} = require('../../is');
-
 const {maybePrintComputed} = require('../object-expression/maybe-print-computed');
 const {maybeParens} = require('../../maybe/maybe-parens');
-
-const {
-    isUnaryExpression,
-    isIfStatement,
-    isCallExpression,
-} = types;
-
-const isArgOfCall = (path) => path.parentPath.isCallExpression() && path.parentPath.get('arguments.0') === path;
+const {isLooksLikeChain} = require('./is-looks-like-chain');
 
 module.exports.MemberExpression = (path, printer) => {
     const {
@@ -35,12 +23,10 @@ module.exports.MemberExpression = (path, printer) => {
     if (computed)
         return maybePrintComputed(path, property, printer);
     
-    const isChain = likeChain(path);
+    const isChain = isLooksLikeChain(path);
     
     maybe.indent.inc(isChain);
-    
-    if (isChain)
-        print.breakline();
+    maybe.print.breakline(isChain);
     
     print('.');
     print('__property');
@@ -65,57 +51,3 @@ module.exports.OptionalMemberExpression = maybeParens((path, {print, maybe}) =>
     
     print('__property');
 });
-
-const isCall = (a) => a.type === 'CallExpression';
-
-const isPathGet = (property) => {
-    return isCallExpression(property, {
-        name: 'get',
-    });
-};
-
-const isExcludedFromChain = satisfy([isUnaryExpression, isIfStatement]);
-
-const isIfUp = (path) => {
-    const ifPath = path.find(isIfStatement);
-    let is = false;
-    
-    if (!ifPath)
-        return is;
-    
-    ifPath.get('test').traverse({
-        MemberExpression(currentPath) {
-            if (path === currentPath) {
-                is = true;
-                path.stop();
-            }
-        },
-    });
-    
-    return is;
-};
-
-module.exports.likeChain = likeChain;
-function likeChain(path) {
-    const [root, properties] = chain(path);
-    
-    if (isExcludedFromChain(root))
-        return false;
-    
-    if (properties.find(isPathGet))
-        return false;
-    
-    if (path.find(isIfUp))
-        return false;
-    
-    const calls = properties.filter(isCall);
-    const [firstCall] = calls;
-    
-    if (calls.length === 2 && !firstCall.name)
-        return false;
-    
-    if (isArgOfCall(path))
-        return false;
-    
-    return calls.length > 1;
-}

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

@@ -1,9 +1,17 @@
 'use strict';
 
+const {types} = require('@putout/babel');
 const {exists} = require('../../is');
 const {isMarkedAfter} = require('../../mark');
-const isInsideExpressionStatement = ({parentPath}) => parentPath.isExpressionStatement();
+
+const {
+    isExpressionStatement,
+    isMemberExpression,
+} = types;
+
+const isInsideExpressionStatement = ({parentPath}) => isExpressionStatement(parentPath);
 const notFirst = ({parentPath}) => exists(parentPath.getPrevSibling());
+const isInsideMember = ({parentPath}) => isMemberExpression(parentPath);
 
 const getPrev = ({parentPath}) => {
     const prev = parentPath.getPrevSibling();
@@ -66,8 +74,9 @@ function maybePrintCloseBrace(path, printer, semantics) {
 function maybePrintBrace(brace, path, printer, semantics) {
     const {maybe, print} = printer;
     const {roundBraces} = semantics;
+    const {length} = path.node.arguments;
     
-    if (path.node.arguments.length)
+    if (length || isInsideMember(path))
         return print(brace);
     
     maybe.print(roundBraces.new, brace);

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

@@ -13,8 +13,8 @@ const {
 } = require('../../is');
 
 const {parseComments} = require('../../comment/comment');
-const {likeChain} = require('../member-expression/member-expressions');
 const {isInsideTuple} = require('./is-inside-tuple');
+const {isLooksLikeChain} = require('../member-expression/is-looks-like-chain');
 
 const {
     isStringLiteral,
@@ -35,7 +35,7 @@ const isMemberExpressionCallee = ({parentPath}) => {
     if (!callee.isMemberExpression())
         return false;
     
-    return likeChain(callee);
+    return isLooksLikeChain(callee);
 };
 
 const isInsideCall = ({parentPath}) => parentPath.isCallExpression();

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

@@ -14,6 +14,8 @@ const {parseComments} = require('../../comment/comment');
 const {insideIfWithNoBody} = require('./inside-if-with-no-body');
 const {getDirectives} = require('./get-directives');
 
+const {isCallInsideChain} = require('./is-call-inside-chain');
+
 const {
     isArrowFunctionExpression,
     isObjectMethod,
@@ -60,6 +62,9 @@ module.exports.BlockStatement = {
         }
         
         maybe.write.linebreak(directives.length && body.length);
+        const callInsideChain = isCallInsideChain(path);
+        
+        maybe.indent.inc(callInsideChain);
         
         for (const element of body) {
             traverse(element);
@@ -71,6 +76,8 @@ module.exports.BlockStatement = {
         maybe.indent(body.length);
         write('}');
         
+        maybe.indent.dec(callInsideChain);
+        
         if (path.parentPath.isObjectMethod())
             write(',');
     },

package/lib/tokenize/statements/block-statement/is-call-inside-chain.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const {types} = require('@putout/babel');
+const {isLooksLikeChain} = require('../../expressions/member-expression/is-looks-like-chain');
+const {
+    isExpressionStatement,
+    isMemberExpression,
+    isCallExpression,
+} = types;
+
+module.exports.isCallInsideChain = (path) => {
+    if (!isCallExpression(path.parentPath.parentPath))
+        return false;
+    
+    const member = path.find(isTopMemberInsideCall);
+    
+    if (member)
+        return isLooksLikeChain(member);
+    
+    const callPath = path.find(isTopCall);
+    
+    if (!callPath)
+        return false;
+    
+    const calleeMember = callPath.get('callee');
+    
+    return isLooksLikeChain(calleeMember);
+};
+
+function isTopMemberInsideCall(path) {
+    if (!isMemberExpression(path))
+        return false;
+    
+    return isExpressionStatement(path.parentPath.parentPath);
+}
+
+function isTopCall(path) {
+    if (!isCallExpression(path))
+        return false;
+    
+    return isExpressionStatement(path.parentPath);
+}

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

@@ -14,6 +14,7 @@ const {
 } = require('../../is');
 
 const not = (fn) => (...a) => !fn(...a);
+
 const isBeforeElse = (path) => {
     if (!path.parentPath.isIfStatement())
         return false;

package/package.json

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