@putout/printer 18.7.1 → 18.7.3

package/ChangeLog

@@ -1,3 +1,15 @@
+2026.03.15, v18.7.3
+
+feature:
+- 126ac069 @putout/printer: type-checker: boolean: +/-
+
+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/expressions/array-expression/indent.js

@@ -62,7 +62,7 @@ const isObjectAfterString = (path) => {
 };
 
 export const isIncreaseIndent = createTypeChecker([
-    ['-: node.elements.length -> !', Boolean],
+    ['-: node.elements.length -> -'],
     ['+', isBooleanAndObject],
     ['-', isInsideCallLoop],
     ['+: node.elements.0 -> ObjectExpression'],

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

@@ -201,7 +201,7 @@ const isBodyWithOneElement = createTypeChecker([
 ]);
 
 export const isMultiLine = createTypeChecker([
-    ['-: node.elements.length -> !', Boolean],
+    ['-: node.elements.length -> -'],
     ['+', isBodyWithOneElement],
     ['+', isMoreThenMaxElementLengthInOneLine],
     ['+', isElementsMoreThenMaxWithFirstString],

package/lib/tokenize/expressions/class/class.js

@@ -22,7 +22,7 @@ const {isFunction} = types;
 const isLessThenTwo = (a) => a < 2;
 
 const isSpaceBeforeImplements = createTypeChecker([
-    ['+: node.typeParameters -> !', Boolean],
+    ['+: node.typeParameters -> -'],
     ['+: node.typeParameters.params.length', isLessThenTwo],
 ]);
 

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

@@ -17,11 +17,11 @@ const hasDirectives = (a) => getDirectives(a).length;
 
 const isNewLineAfterOpenCurlyBrace = createTypeChecker([
     ['+', hasDirectives],
-    ['+: node.body.length', Boolean],
+    ['+: node.body.length -> +'],
 ]);
 
 const isLinebreakAfterDirectives = createTypeChecker([
-    ['-: node.body.length -> !', Boolean],
+    ['-: node.body.length -> -'],
     ['+', hasDirectives],
 ]);
 

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

@@ -34,7 +34,7 @@ const isPathIsConsequent = ({node, parentPath}) => node !== parentPath.node.cons
 const isBeforeElse = createTypeChecker([
     ['-: parentPath -> !IfStatement'],
     ['-', isPathIsConsequent],
-    ['+: parentPath.node.alternate', Boolean],
+    ['+: parentPath.node.alternate -> +'],
 ]);
 
 const hasTrailingCommentNotCoupleLines = createTypeChecker([

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 -> +',
+]);
+
+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 -> +',
+]);

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

@@ -90,6 +90,7 @@ const isNewlineAfterClosingCurlyBrace = createTypeChecker([
 ]);
 
 const isNewlineAfterColon = createTypeChecker([
-    ['-: node.consequent.length -> !', Boolean],
-    ['+: node.consequent.0 -> !BlockStatement'],
+    '-: node.consequent.length -> -',
+    '+: node.consequent.0 -> !BlockStatement',
 ]);
+

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

@@ -4,6 +4,18 @@ export function createTuple(typeName) {
     const array = typeWithNot.split('!');
     const operation = afterSplit.join(' ');
     
+    if (typeWithNot === '+')
+        return [
+            `${operation} `,
+            Boolean,
+        ];
+    
+    if (typeWithNot === '-')
+        return [
+            `${operation} !`,
+            Boolean,
+        ];
+    
     if (array.length === 1)
         return [
             `${operation} `,

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.3",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",