@putout/printer 1.49.1 → 1.51.0

package/ChangeLog

@@ -1,3 +1,18 @@
+2023.04.17, v1.51.0
+
+feature:
+- 0fc4fb0 @putout/printer: add ability to preserve newline between ExpressionStatements
+- 8073d64 @putout/printer: CallExpression: simplify
+- b94009b @putout/printer: add ability to preserve newline
+
+2023.04.14, v1.50.0
+
+fix:
+- 6203f72 @putout/printer: ArrayExpression: one element CallExpression
+
+feature:
+- 491126f @putout/printer: ArrayExpression: two elements ReturnStatement: no newline
+
 2023.04.14, v1.49.1
 
 fix:

package/lib/tokenize/comments.js

@@ -1,14 +1,8 @@
 'use strict';
 
-const {
-    isFirst,
-    isNext,
-} = require('./is');
+const {isNext} = require('./is');
 
-const {
-    markBefore,
-    hasPrevNewline,
-} = require('./mark');
+const {markBefore} = require('./mark');
 
 module.exports.parseLeadingComments = (path, {print, maybe}) => {
     const {leadingComments} = path.node;
@@ -16,9 +10,6 @@ module.exports.parseLeadingComments = (path, {print, maybe}) => {
     if (!leadingComments || !leadingComments.length)
         return;
     
-    if (shouldAddNewlineBefore(path))
-        print.linebreak();
-    
     const isClass = !path.isClassMethod();
     
     for (const {type, value} of leadingComments) {
@@ -65,10 +56,6 @@ module.exports.parseTrailingComments = (path, {write, maybe}) => {
     }
 };
 
-function shouldAddNewlineBefore(path) {
-    return path.isStatement() && !isFirst(path) && !hasPrevNewline(path);
-}
-
 function isSameLine(path, loc) {
     return path.node.loc.start.line === loc.start.line;
 }

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

@@ -21,6 +21,9 @@ const isStringAndString = ([a, b]) => isStringLiteral(a) && isStringLiteral(b);
 const isIdentifierAndIdentifier = ([a, b]) => isIdentifier(a) && isIdentifier(b);
 const isArrayParent = (path) => path.parentPath.isArrayExpression();
 
+const isOneElementCall = (path, {elements}) => path.parentPath.isCallExpression() && elements.length === 1;
+const isTwoElementReturn = (path, {elements}) => path.parentPath.isReturnStatement() && elements.length === 2;
+
 const isTwoLongStrings = ([a, b]) => {
     const LONG_STRING = 20;
     
@@ -172,10 +175,13 @@ function tooLong(path) {
 }
 
 function isNewlineBetweenElements(path, {elements}) {
-    if (isIncreaseIndent(path))
+    if (isTwoElementReturn(path, {elements}))
         return false;
     
-    if (isInsideCallLoop(path))
+    if (isOneElementCall(path, {elements}))
+        return false;
+    
+    if (isIncreaseIndent(path))
         return false;
     
     if (isInsideLoop(path))

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

@@ -2,58 +2,55 @@
 
 const {exists} = require('../is');
 
-const CallExpression = {
-    print(path, {indent, print, maybe, traverse}) {
-        const isParentCall = toLong(path) && path.parentPath.isCallExpression();
-        const callee = path.get('callee');
-        const typeParameters = path.get('typeParameters');
-        const isFn = callee.isFunction();
-        
-        maybe.write(isFn, '(');
-        traverse(callee);
-        
-        if (exists(typeParameters))
-            traverse(typeParameters);
-        
-        maybe.write(isFn, ')');
-        
-        if (path.node.optional)
-            print('?.');
-        
-        print('(');
-        
-        const args = path.get('arguments');
-        const n = args.length - 1;
-        
-        maybe.indent.inc(isParentCall);
+function CallExpression(path, {indent, print, maybe, traverse}) {
+    const isParentCall = toLong(path) && path.parentPath.isCallExpression();
+    const callee = path.get('callee');
+    const typeParameters = path.get('typeParameters');
+    const isFn = callee.isFunction();
+    
+    maybe.write(isFn, '(');
+    traverse(callee);
+    
+    if (exists(typeParameters))
+        traverse(typeParameters);
+    
+    maybe.write(isFn, ')');
+    
+    if (path.node.optional)
+        print('?.');
+    
+    print('(');
+    
+    const args = path.get('arguments');
+    const n = args.length - 1;
+    
+    maybe.indent.inc(isParentCall);
+    
+    for (const [i, arg] of args.entries()) {
+        const isObject = arg.isObjectExpression();
         
-        for (const [i, arg] of args.entries()) {
-            const isObject = arg.isObjectExpression();
-            
-            if (isParentCall && !isObject) {
-                print.newline();
-                indent();
-            }
-            
-            print(arg);
-            
-            if (isParentCall) {
-                print(',');
-                continue;
-            }
-            
-            maybe.print(i < n, ', ');
+        if (isParentCall && !isObject) {
+            print.newline();
+            indent();
         }
         
+        print(arg);
+        
         if (isParentCall) {
-            indent.dec();
-            print.breakline();
+            print(',');
+            continue;
         }
         
-        print(')');
-    },
-};
-
+        maybe.print(i < n, ', ');
+    }
+    
+    if (isParentCall) {
+        indent.dec();
+        print.breakline();
+    }
+    
+    print(')');
+}
 module.exports.OptionalCallExpression = CallExpression;
 module.exports.CallExpression = CallExpression;
 

package/lib/tokenize/is.js

@@ -38,7 +38,6 @@ module.exports.isParentBlock = isParentBlock;
 module.exports.isLast = isLast;
 module.exports.isParentLast = (path) => isLast(path.parentPath);
 module.exports.isCoupleLines = isCoupleLines;
-module.exports.isNextCoupleLines = isNextCoupleLines;
 
 function isCoupleLines(path) {
     const start = path.node?.loc?.start?.line;
@@ -47,10 +46,6 @@ function isCoupleLines(path) {
     return end > start;
 }
 module.exports.exists = (a) => a.node;
-
-function isNextCoupleLines(path) {
-    return isCoupleLines(path.getNextSibling());
-}
 module.exports.isStringAndIdentifier = ([a, b]) => isStringLiteral(a) && isIdentifier(b);
 
 const isIfOrStatement = (a) => isIfStatement(a) || isStatement(a);
@@ -71,3 +66,13 @@ module.exports.isForOf = (path) => {
     
     return false;
 };
+
+module.exports.isNewlineBetweenStatements = (path) => {
+    const endCurrent = path.node?.loc?.end?.line;
+    const startNext = path.getNextSibling().node?.loc?.start?.line;
+    
+    if (!startNext)
+        return false;
+    
+    return startNext - endCurrent > 1;
+};

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

@@ -5,20 +5,10 @@ const {
     isParentProgram,
     isLast,
     isParentBlock,
-    isCoupleLines,
-    isNextCoupleLines,
     isParentLast,
+    isNewlineBetweenStatements,
 } = require('../is');
 
-const isNextDifferent = (path) => {
-    const next = path.getNextSibling();
-    
-    if (!next.isExpressionStatement())
-        return true;
-    
-    return next.node.expression.type !== path.node.expression.type;
-};
-
 module.exports.ExpressionStatement = {
     print(path, {indent, print, maybe, store}) {
         indent();
@@ -41,6 +31,9 @@ module.exports.ExpressionStatement = {
 };
 
 function shouldBreakline(path) {
+    if (isNewlineBetweenStatements(path))
+        return true;
+    
     if (isLast(path) || isParentLast(path))
         return false;
     
@@ -53,12 +46,6 @@ function shouldBreakline(path) {
     if (isStrictMode(path))
         return true;
     
-    if (isNext(path) && isNextDifferent(path) && path.parentPath.node.body?.length > 2)
-        return true;
-    
-    if (isCoupleLines(path) || isNextCoupleLines(path))
-        return true;
-    
     return false;
 }
 

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

@@ -1,18 +1,10 @@
 'use strict';
 
-const {
-    hasPrevNewline,
-    markAfter,
-} = require('../mark');
+const {markAfter} = require('../mark');
 
-const {isFirst} = require('../is');
 const isEmptyConsequent = (path) => path.get('consequent').isEmptyStatement();
 
 module.exports.IfStatement = {
-    before: (path, {print}) => {
-        print.linebreak();
-    },
-    beforeIf: shouldAddNewlineBefore,
     print: (path, {indent, print, maybe, write, traverse}) => {
         indent();
         print('if (');
@@ -66,10 +58,3 @@ module.exports.IfStatement = {
         markAfter(path);
     },
 };
-
-function shouldAddNewlineBefore(path) {
-    if (path.parentPath.isIfStatement())
-        return false;
-    
-    return !isFirst(path) && !hasPrevNewline(path);
-}

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

@@ -3,6 +3,7 @@
 const {
     isNext,
     isCoupleLines,
+    isNewlineBetweenStatements,
 } = require('../is');
 
 const {
@@ -67,6 +68,9 @@ function shouldAddNewlineAfter(path) {
     if (prev.isVariableDeclaration() && !next.isVariableDeclaration())
         return true;
     
+    if (isNewlineBetweenStatements(path))
+        return true;
+    
     return false;
 }
 const isLast = (path) => path.parentPath.isProgram() && !isNext(path);

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

@@ -7,9 +7,11 @@ module.exports.TSTypeAliasDeclaration = {
     print(path, {print, maybe, store}) {
         print('type ');
         print('__id');
+        
         print.space();
         print('=');
         print.space();
+        
         print('__typeAnnotation');
         print(';');
         

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.49.1",
+  "version": "1.51.0",
   "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",