@putout/printer 18.7.1 → 18.7.2

package/ChangeLog

@@ -1,3 +1,10 @@
+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:

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,33 +1,8 @@
-import {types} from '@putout/babel';
-import {hasPrevNewline} from '#mark';
+import {isInsideLabel} from '#is';
 import {createTypeChecker} from '#type-checker';
-import {
-    isInsideLabel,
-    noTrailingComment,
-    isLast,
-    callWithPrev,
-} from '#is';
 import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
-
-const {
-    isJSXElement,
-    isTryStatement,
-    isBlockStatement,
-} = types;
-
-const isBodyLength = ({parentPath}) => parentPath.node?.body?.length > 2;
-
-const isInsideIfWithElse = createTypeChecker([
-    ['-: parentPath -> !IfStatement'],
-    ['+: parentPath.node.alternate', Boolean],
-]);
-
-const beforeIf = createTypeChecker([
-    ['+', callWithPrev(isTryStatement)],
-    ['-: ->', hasPrevNewline],
-    ['+: ->', isBodyLength],
-    ['+: ->', callWithPrev(isBlockStatement)],
-]);
+import {beforeIf} from './before-if.js';
+import {afterIf} from './after-if.js';
 
 export const ReturnStatement = {
     beforeIf,
@@ -56,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.1",
+  "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",