@putout/printer 18.7.0 → 18.7.2

package/ChangeLog

@@ -1,3 +1,15 @@
+2026.03.15, v18.7.2
+
+feature:
+- 03c11aa @putout/printer: ReturnStatements: maybeSpaceAfterKeyword: simplify
+- 2a0d633 @putout/printer: ReturnStatement: isJSXWithComment
+- 3ee3a68 @putout/printer: ReturnStatement: afterIf
+
+2026.03.14, v18.7.1
+
+feature:
+- 5003310 @putout/printer: ReturnStatement: simplify
+
 2026.03.14, v18.7.0
 
 feature:

package/lib/tokenize/expressions/assignment-expression/assignment-expression-comments.js

@@ -35,6 +35,7 @@ export const maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
         const {leadingComments} = path.node;
         
         print.breakline();
+        
         for (const {type, value} of leadingComments) {
             if (type === 'CommentLine')
                 print(`//${value}`);

package/lib/tokenize/is.js

@@ -51,8 +51,6 @@ export const isNextTry = (path) => {
     return isTryStatement(path.getNextSibling());
 };
 
-export const isPrevTry = (path) => isTryStatement(path.getPrevSibling());
-
 export const isPrev = (path) => {
     const next = path.getPrevSibling();
     return next.node;
@@ -62,10 +60,6 @@ export const isNextParent = (path) => isNext(path.parentPath);
 export const isLast = (path) => isInsideProgram(path) && !isNext(path);
 
 export const isFirst = (path) => path.node === path.parentPath.node.body?.[0];
-export const isPrevBody = (path) => path
-    .getPrevSibling()
-    .isBlockStatement();
-
 export const isParentLast = (path) => isLast(path.parentPath);
 
 export function isCoupleLines(path) {

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

@@ -0,0 +1,17 @@
+import {
+    isLast,
+    noTrailingComment,
+} from '#is';
+import {createTypeChecker} from '#type-checker';
+
+const isInsideIfWithElse = createTypeChecker([
+    ['-: parentPath -> !IfStatement'],
+    ['+: parentPath.node.alternate', Boolean],
+]);
+
+export const afterIf = createTypeChecker([
+    ['+', isInsideIfWithElse],
+    ['-', isLast],
+    ['-: parentPath', isLast],
+    ['+', noTrailingComment],
+]);

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

@@ -0,0 +1,18 @@
+import {types} from '@putout/babel';
+import {callWithPrev} from '#is';
+import {hasPrevNewline} from '#mark';
+import {createTypeChecker} from '#type-checker';
+
+const {
+    isTryStatement,
+    isBlockStatement,
+} = types;
+
+const isBodyLength = ({parentPath}) => parentPath.node?.body?.length > 2;
+
+export const beforeIf = createTypeChecker([
+    ['+', callWithPrev(isTryStatement)],
+    ['-: ->', hasPrevNewline],
+    ['+: ->', isBodyLength],
+    ['+: ->', callWithPrev(isBlockStatement)],
+]);

package/lib/tokenize/statements/return-statement/maybe-space-after-keyword.js

@@ -1,3 +1,9 @@
+import {createTypeChecker} from '#type-checker';
+
+const isSequenceOption = (a, {roundBraces}) => roundBraces.sequence;
+const isArrowOption = (a, {roundBraces}) => roundBraces.arrow;
+const isNot = (a) => a === '!';
+
 export const maybeSpaceAfterKeyword = (path, {print}, semantics) => {
     const {roundBraces} = semantics;
     const {node} = path;
@@ -5,22 +11,35 @@ export const maybeSpaceAfterKeyword = (path, {print}, semantics) => {
     if (!node)
         return;
     
-    const {type} = node;
-    
-    if (type === 'SequenceExpression' && roundBraces.sequence)
-        return print.space();
-    
-    if (type === 'StringLiteral' || type === 'TemplateLiteral')
-        return print.space();
-    
-    if (type === 'ArrayExpression' || type === 'ObjectExpression')
-        return print.space();
-    
-    if (type === 'UnaryExpression' && node.operator === '!')
-        return print.space();
-    
-    if (type === 'ArrowFunctionExpression' && roundBraces.arrow)
-        return print.space();
+    if (isOptionalSpace(path, {roundBraces})) {
+        print.space();
+        return;
+    }
     
     print(' ');
 };
+
+const isSequenceWithOption = createTypeChecker([
+    ['-: -> !SequenceExpression'],
+    ['+', isSequenceOption],
+]);
+
+const isArrowWithOption = createTypeChecker([
+    ['-: -> !ArrowFunctionExpression'],
+    ['+', isArrowOption],
+]);
+
+const isUnaryNot = createTypeChecker([
+    ['-: -> !UnaryExpression'],
+    ['+: node.operator', isNot],
+]);
+
+const isOptionalSpace = createTypeChecker([
+    ['+: -> StringLiteral'],
+    ['+: -> TemplateLiteral'],
+    ['+: -> ArrayExpression'],
+    ['+: -> ObjectExpression'],
+    ['+', isUnaryNot],
+    ['+', isSequenceWithOption],
+    ['+', isArrowWithOption],
+]);

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

@@ -1,26 +1,11 @@
-import {types} from '@putout/babel';
-import {hasPrevNewline} from '#mark';
-import {
-    isInsideLabel,
-    isPrevBody,
-    noTrailingComment,
-    isLast,
-    isPrevTry,
-} from '#is';
+import {isInsideLabel} from '#is';
+import {createTypeChecker} from '#type-checker';
 import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
-
-const {isJSXElement} = types;
-const isBodyLength = ({parentPath}) => parentPath.node?.body?.length > 2;
-
-const isInsideIfWithElse = ({parentPath}) => parentPath.isIfStatement() && parentPath.node.alternate;
+import {beforeIf} from './before-if.js';
+import {afterIf} from './after-if.js';
 
 export const ReturnStatement = {
-    beforeIf(path) {
-        if (isPrevTry(path))
-            return true;
-        
-        return !hasPrevNewline(path) && isBodyLength(path) || isPrevBody(path);
-    },
+    beforeIf,
     before(path, {print}) {
         print.linebreak();
     },
@@ -46,30 +31,13 @@ export const ReturnStatement = {
         print('__argument');
         print(';');
     },
-    afterIf: (path) => {
-        if (isInsideIfWithElse(path))
-            return true;
-        
-        if (isLast(path))
-            return false;
-        
-        if (isLast(path.parentPath))
-            return false;
-        
-        return noTrailingComment(path);
-    },
+    afterIf,
     after(path, {print}) {
         print.newline();
     },
 };
 
-function isJSXWithComment(path) {
-    const arg = path.node.argument;
-    
-    if (!arg)
-        return;
-    
-    const {leadingComments} = arg;
-    
-    return isJSXElement(arg) && leadingComments?.length;
-}
+const isJSXWithComment = createTypeChecker([
+    ['-: node.argument -> !JSXElement'],
+    ['+: node.argument.leadingComments ->', Boolean],
+]);

package/lib/tokenize/type-checker/type-checker.js

@@ -14,13 +14,13 @@ export const createTypeChecker = (typeNames, overrides = {}) => {
     } = overrides;
     
     const tuples = parseTypeNames(typeNames);
-    const checkers = new Set();
+    const checkers = [];
     const results = new Set();
     
     for (const [operation, typeName] of tuples) {
         const [result, selector, not] = parseOperation(operation);
         results.add(result);
-        checkers.add({
+        checkers.push({
             result,
             selector,
             not,

package/package.json

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