@putout/printer 18.18.0 → 18.20.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2026.06.20, v18.20.0
+
+feature:
+- b38b9939 @putout/printer: new line before leading Comment, after CallExpression
+
+2026.06.19, v18.19.0
+
+feature:
+- ec918867 @putout/printer: @babel/parser v8.0.0
+- 339814ed @putout/printer: TSImportEqualsDeclaration: newline
+
 2026.06.10, v18.18.0
 
 feature:

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

@@ -1,14 +1,27 @@
+import {types} from '@putout/babel';
 import {createTypeChecker} from '#type-checker';
 import {
     hasTrailingComment,
-    isCoupleLines,
     isInsideBlock,
+    isInsideReturn,
     isLast,
     isNext,
     isParentLast,
     satisfy,
+    exists,
+    isCoupleLines,
 } from '#is';
 
+const {
+    isCallExpression,
+    isAssignmentExpression,
+    isArrayExpression,
+    isStringLiteral,
+    isTemplateLiteral,
+    isExpressionStatement,
+    isStatement,
+} = types;
+
 function isNotLastOrParentLast(path) {
     return !isLast(path) && !isParentLast(path);
 }
@@ -37,16 +50,80 @@ const isBeforeElse = createTypeChecker([
     ['+: parentPath.node.alternate -> +'],
 ]);
 
-const hasTrailingCommentNotCoupleLines = createTypeChecker([
-    ['-: -> !', hasTrailingComment],
-    ['+: -> !', isCoupleLines],
-]);
+const isNextCallWithLeadingComments = (path) => {
+    const next = path.getNextSibling();
+    
+    if (!exists(next))
+        return false;
+    
+    if (!path.node.trailingComments)
+        return false;
+    
+    if (isStatement(next) && isCoupleLines(path))
+        return true;
+    
+    if (!isExpressionStatement(next))
+        return false;
+    
+    const {expression} = path.node;
+    
+    if (isCallExpression(expression))
+        return true;
+    
+    const nextExpression = next.get('expression');
+    
+    return isCallExpression(nextExpression);
+};
+
+function isNextWithLeadingComments(path) {
+    const next = path.getNextSibling();
+    const {expression} = path.node;
+    
+    if (!path.node.trailingComments)
+        return true;
+    
+    if (isAssignmentExpression(expression))
+        return true;
+    
+    return !exists(next);
+}
+
+export function isNextSimpleWithLeadingComments(path) {
+    const next = path.getNextSibling();
+    
+    if (!hasTrailingComment(path))
+        return false;
+    
+    if (!isExpressionStatement(next))
+        return false;
+    
+    const {expression} = next.node;
+    
+    if (isStringLiteral(expression))
+        return true;
+    
+    if (isTemplateLiteral(expression))
+        return true;
+    
+    return isArrayExpression(next.node.expression);
+}
+
+function isAssignWithTrailingComments(path) {
+    const {expression} = path.node;
+    
+    if (!isAssignmentExpression(expression))
+        return false;
+    
+    return hasTrailingComment(path);
+}
 
 export const afterIf = createTypeChecker([
+    ['-', isInsideReturn],
     ['-', isTopParentLast],
-    ['-', hasTrailingCommentNotCoupleLines],
+    ['+', isNextCallWithLeadingComments],
+    ['-: -> !', isNextWithLeadingComments],
+    ['+', isAssignWithTrailingComments],
+    ['-: node.trailingComments.length -> +'],
     ['+', satisfyAfter],
     ['+', isBeforeElse],
-    ['-: -> !', hasTrailingComment],
-    ['+', isLast],
 ]);

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

@@ -2,11 +2,8 @@ import {types} from '@putout/babel';
 import {createTypeChecker} from '#type-checker';
 import {
     isNext,
-    isLast,
     isNewlineBetweenSiblings,
     noTrailingComment,
-    hasTrailingComment,
-    isCoupleLines,
     isInsideReturn,
     callWithNext,
     hasLeadingComment,
@@ -15,7 +12,10 @@ import {
     printLeadingCommentLine,
     printLeadingCommentBlock,
 } from './comments.js';
-import {afterIf} from './after-if.js';
+import {
+    afterIf,
+    isNextSimpleWithLeadingComments,
+} from './after-if.js';
 import {beforeIf} from './before-if.js';
 
 const {isIfStatement} = types;
@@ -30,12 +30,6 @@ const isNextToAssignmentCall = createTypeChecker([
     ['+', callWithNext(isCallInsideExpression)],
 ]);
 
-const isBreaklineAfter = createTypeChecker([
-    ['-: -> !', hasTrailingComment],
-    ['-: -> !', isLast],
-    ['+', isCoupleLines],
-]);
-
 const isNextStatementWithBlockComment = createTypeChecker([
     '-: node.expression -> !CallExpression',
     '-: node.expression.arguments.0 -> !CallExpression',
@@ -80,13 +74,11 @@ export const ExpressionStatement = {
     },
     afterIf,
     after(path, {print, maybe, store}) {
-        maybe.print.breakline(isBreaklineAfter(path));
+        maybe.indent(isIndentAfter(path));
         
-        if (isInsideReturn(path))
-            return;
+        if (!isNextSimpleWithLeadingComments(path))
+            print.newline();
         
-        maybe.indent(isIndentAfter(path));
-        print.newline();
         maybe.markAfter(store(), path);
     },
 };

package/lib/tokenize/typescript/index.js

@@ -1,4 +1,3 @@
-import {isNext} from '#is';
 import {printParams} from '#print-params';
 import {maybePrintTypeAnnotation} from '../maybe/maybe-type-annotation.js';
 
@@ -12,6 +11,7 @@ export {TSDeclareFunction} from './function/ts-declare-function.js';
 export {TSDeclareMethod} from './function/ts-declare-method.js';
 export {TSModuleDeclaration, TSModuleBlock} from './namespace/ts-module-declaration.js';
 export {TSInterfaceDeclaration} from './interface/ts-interface-declaration.js';
+export {TSImportEqualsDeclaration} from './ts-import-equals-declaration/ts-import-equals-declaration.js';
 export {TSAsExpression} from './ts-as-expression/ts-as-expression.js';
 export {TSInterfaceBody} from './interface/ts-interface-body.js';
 export {TSIntersectionType} from './ts-intersection-type.js';
@@ -151,17 +151,6 @@ export const TSTypePredicate = (path, {print}) => {
     print('__typeAnnotation');
 };
 
-export const TSImportEqualsDeclaration = (path, {print, maybe}) => {
-    maybe.print(path.node.isExport, 'export ');
-    print('import ');
-    print('__id');
-    print.space();
-    print('=');
-    print.space();
-    print('__moduleReference');
-    print(';');
-    maybe.print.newline(isNext(path));
-};
 export const TSExternalModuleReference = (path, {print}) => {
     print('require(');
     print('__expression');

package/lib/tokenize/typescript/ts-import-equals-declaration/ts-import-equals-declaration.js

@@ -0,0 +1,15 @@
+import {isLast} from '#is';
+
+export const TSImportEqualsDeclaration = (path, {print, maybe}) => {
+    maybe.print(path.node.isExport, 'export ');
+    print('import ');
+    print('__id');
+    print.space();
+    print('=');
+    print.space();
+    print('__moduleReference');
+    print(';');
+    
+    if (!isLast(path) && !isLast(path.parentPath))
+        print.newline();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "18.18.0",
+  "version": "18.20.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -76,7 +76,7 @@
     "#comments": "./lib/tokenize/comments/comments.js"
   },
   "devDependencies": {
-    "@babel/parser": "^7.28.5",
+    "@babel/parser": "^8.0.0",
     "@putout/eslint": "^6.0.0",
     "@putout/eslint-flat": "^4.0.0",
     "@putout/plugin-minify": "^12.0.0",