@putout/printer 1.54.1 → 1.54.3

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.04.18, v1.54.3
+
+feature:
+- b5acf3e @putout/printer: improve support of newlines between elements of ArrayExpression
+
+2023.04.18, v1.54.2
+
+feature:
+- a9c17af @putout/printer: improve support of ArrowFunctionExpression used inside LogicalExpression
+
 2023.04.18, v1.54.1
 
 feature:

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

@@ -174,7 +174,22 @@ function tooLong(path) {
     return false;
 }
 
+function isCallInsideArrow(path) {
+    const {parentPath} = path;
+    
+    if (!parentPath.isCallExpression())
+        return false;
+    
+    if (!parentPath.parentPath.isFunction())
+        return false;
+    
+    return path.node.elements.length < 4;
+}
+
 function isNewlineBetweenElements(path, {elements}) {
+    if (isCallInsideArrow(path))
+        return false;
+    
     if (isTwoElementReturn(path, {elements}))
         return false;
     

package/lib/tokenize/expressions/functions/arrow-function-expression.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const {exists} = require('../../is');
+
+module.exports.ArrowFunctionExpression = {
+    condition({parentPath}) {
+        return parentPath.isLogicalExpression();
+    },
+    before(path, {write}) {
+        write('(');
+    },
+    print(path, {print, maybe, write, traverse}) {
+        const {async} = path.node;
+        
+        maybe.print(async, 'async ');
+        print('(');
+        
+        const params = path.get('params');
+        const n = params.length;
+        
+        for (let i = 0; i < n; i++) {
+            print(params[i]);
+            
+            if (i < n - 1)
+                print(', ');
+        }
+        
+        print(')');
+        
+        const returnType = path.get('returnType');
+        
+        if (exists(returnType)) {
+            write(':');
+            write.space();
+            traverse(returnType);
+        }
+        
+        print.space();
+        print('=>');
+        print.space();
+        print('__body');
+    },
+    after(path, {write}) {
+        write(')');
+    },
+};

package/lib/tokenize/expressions/functions/function-declaration.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const {hasPrevNewline} = require('../../mark');
+const isFirst = (path) => !path.getPrevSibling().node;
+
+module.exports.FunctionDeclaration = {
+    beforeIf(path) {
+        return !isFirst(path) && !hasPrevNewline(path) && !path.parentPath.isExportDeclaration();
+    },
+    before(path, {write}) {
+        write('\n');
+    },
+    print(path, {print, maybe}) {
+        const {async} = path.node;
+        
+        maybe.print(async, 'async ');
+        
+        print('function ');
+        print('__id');
+        print('(');
+        
+        const params = path.get('params');
+        const n = params.length - 1;
+        
+        for (let i = 0; i <= n; i++) {
+            print(params[i]);
+            
+            if (i < n)
+                print(', ');
+        }
+        
+        print(') ');
+        print('__body');
+    },
+};
+

package/lib/tokenize/expressions/{functions.js → functions/functions.js}

@@ -1,8 +1,10 @@
 'use strict';
 
-const {hasPrevNewline} = require('../mark');
-const {exists} = require('../is');
-const isFirst = (path) => !path.getPrevSibling().node;
+const {ArrowFunctionExpression} = require('./arrow-function-expression');
+const {FunctionDeclaration} = require('./function-declaration');
+
+module.exports.ArrowFunctionExpression = ArrowFunctionExpression;
+module.exports.FunctionDeclaration = FunctionDeclaration;
 
 module.exports.FunctionExpression = (path, {print, maybe, write, traverse}) => {
     const {node} = path;
@@ -39,38 +41,6 @@ module.exports.FunctionExpression = (path, {print, maybe, write, traverse}) => {
     print('__body');
 };
 
-module.exports.ArrowFunctionExpression = ArrowFunctionExpression;
-
-function ArrowFunctionExpression(path, {print, maybe, write, traverse}) {
-    const {async} = path.node;
-    maybe.print(async, 'async ');
-    print('(');
-    
-    const params = path.get('params');
-    const n = params.length;
-    
-    for (let i = 0; i < n; i++) {
-        print(params[i]);
-        
-        if (i < n - 1)
-            print(', ');
-    }
-    
-    print(')');
-    
-    const returnType = path.get('returnType');
-    
-    if (exists(returnType)) {
-        write(':');
-        write.space();
-        traverse(returnType);
-    }
-    
-    print.space();
-    print('=>');
-    print.space();
-    print('__body');
-}
 module.exports.ObjectMethod = (path, {print}) => {
     const {kind} = path.node;
     
@@ -94,31 +64,6 @@ module.exports.ObjectMethod = (path, {print}) => {
     print('__body');
 };
 
-module.exports.FunctionDeclaration = (path, {print, maybe}) => {
-    const {async} = path.node;
-    
-    if (!isFirst(path) && !hasPrevNewline(path) && !path.parentPath.isExportDeclaration())
-        print('\n');
-    
-    maybe.print(async, 'async ');
-    print('function ');
-    print('__id');
-    print('(');
-    
-    const params = path.get('params');
-    const n = params.length - 1;
-    
-    for (let i = 0; i <= n; i++) {
-        print(params[i]);
-        
-        if (i < n)
-            print(', ');
-    }
-    
-    print(') ');
-    print('__body');
-};
-
 module.exports.ClassMethod = (path, {print, maybe}) => {
     const {kind} = path.node;
     const notMethod = kind !== 'method';

package/lib/tokenize/expressions/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const functions = require('./functions');
+const functions = require('./functions/functions');
 const unaryExpressions = require('./unary-expressions');
 const memberExpressions = require('./member-expressions');
 

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

@@ -114,4 +114,3 @@ function isLooksLikeChain(path) {
     
     return !compare(parentPath, '__a.__b(__args)') || itMember || itExpression;
 }
-

package/lib/tokenize/is.js

@@ -79,8 +79,5 @@ module.exports.isNewlineBetweenStatements = (path) => {
 
 module.exports.satisfy = (conditions) => (path) => {
     for (const condition of conditions)
-        if (condition(path))
-            return true;
-    
-    return false;
+        return false;
 };

package/lib/tokenize/statements/export-default-declaration.js

@@ -1,14 +1,21 @@
 'use strict';
 
+const {isNewlineBetweenStatements} = require('../is');
+const {isMarkedAfter} = require('../mark');
+
 module.exports.ExportDefaultDeclaration = {
-    /*
     beforeIf(path) {
-        return path.getPrevSibling().isTSTypeAliasDeclaration();
+        const prev = path.getPrevSibling();
+        
+        if (isMarkedAfter(prev))
+            return false;
+        
+        return isNewlineBetweenStatements(prev);
     },
     before(path, {print}) {
-        print.breakline();
+        print.newline();
     },
-     */print(path, {print, traverse, maybe}) {
+    print(path, {print, traverse, maybe}) {
         const declaration = path.get('declaration');
         print('export default ');
         traverse(declaration);

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

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

package/lib/tokenize/typescript/ts-type-alias-declaration.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {isLast} = require('../is');
+const {markAfter} = require('../mark');
 const isNextType = (a) => a.getNextSibling().isTSTypeAliasDeclaration();
 
 module.exports.TSTypeAliasDeclaration = {
@@ -31,5 +32,6 @@ module.exports.TSTypeAliasDeclaration = {
     },
     after(path, {print}) {
         print.newline();
+        markAfter(path);
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.54.1",
+  "version": "1.54.3",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Easiest possible opinionated Babel AST printer made with ❤️  to use in 🐊Putout",