@putout/printer 18.7.2 → 18.7.4

package/ChangeLog

@@ -1,3 +1,13 @@
+2026.03.16, v18.7.4
+
+feature:
+- a03e0d22 @putout/printer: type-checker: comparison
+
+2026.03.15, v18.7.3
+
+feature:
+- 126ac069 @putout/printer: type-checker: boolean: +/-
+
 2026.03.15, v18.7.2
 
 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'],
@@ -98,12 +98,10 @@ export function isArrayInsideArray(path) {
     return length <= 3 && length !== 1;
 }
 
-const isTwo = (a) => a === 2;
-
 export const isHideIndent = createTypeChecker([
     ['-: -> !', isInsideArray],
     ['-: parentPath -> !', isStringAndArray],
-    ['+: parentPath.node.elements.length', isTwo],
+    ['+: parentPath.node.elements.length', '=', 2],
 ]);
 
 const isLastElementObjectExpression = ({node}) => isObjectExpression(node.elements.at(-1));

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

@@ -162,10 +162,8 @@ const hasObjects = (path) => {
     return literals.length;
 };
 
-const isLessThenTwo = (a) => a < 2;
-
 const isMoreThenMaxElementLengthInOneLine = createTypeChecker([
-    ['-: node.elements.length', isLessThenTwo],
+    ['-: node.elements.length', '<', 2],
     ['-: -> !', isInsideCall],
     ['-', hasObjects],
     ['+', isMoreThenMaxLiteralLength],
@@ -192,16 +190,15 @@ const isElementsMoreThenMaxWithFirstString = createTypeChecker([
     ['+', isElementsMoreThenMax],
 ]);
 
-const isOne = (a) => a === 1;
 const isBody = ({node, parentPath}) => node === parentPath.node.body;
 
 const isBodyWithOneElement = createTypeChecker([
-    ['-: node.elements.length -> !', isOne],
+    ['-: node.elements.length -> !', '=', 1],
     ['+', isBody],
 ]);
 
 export const isMultiLine = createTypeChecker([
-    ['-: node.elements.length -> !', Boolean],
+    ['-: node.elements.length -> -'],
     ['+', isBodyWithOneElement],
     ['+', isMoreThenMaxElementLengthInOneLine],
     ['+', isElementsMoreThenMaxWithFirstString],
@@ -311,3 +308,4 @@ export const isIndentBeforeElement = createTypeChecker([
     ['+: -> SpreadElement'],
     ['+: -> !ObjectExpression'],
 ]);
+

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

@@ -19,11 +19,10 @@ const afterIf = createTypeChecker([
 ]);
 
 const {isFunction} = types;
-const isLessThenTwo = (a) => a < 2;
 
 const isSpaceBeforeImplements = createTypeChecker([
-    ['+: node.typeParameters -> !', Boolean],
-    ['+: node.typeParameters.params.length', isLessThenTwo],
+    ['+: node.typeParameters -> -'],
+    ['+: node.typeParameters.params.length', '<', 2],
 ]);
 
 const classVisitor = maybeDecorators((path, printer, semantics) => {

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

@@ -6,22 +6,20 @@ import {getDirectives} from './get-directives.js';
 import {isCallInsideChain} from './is-call-inside-chain.js';
 import {shouldAddNewlineAfter} from './block-statement-newline.js';
 
-const isThree = (a) => a === 3;
-
 const isInsideArrayTupleOfThree = createTypeChecker([
     ['-: parentPath.parentPath -> !ArrayExpression'],
-    ['+: parentPath.parentPath.node.elements.length', isThree],
+    ['+: parentPath.parentPath.node.elements.length', '=', 3],
 ]);
 
 const hasDirectives = (a) => getDirectives(a).length;
 
-const isNewLineAfterOpenCurlyBrace = createTypeChecker([
+const isNewlineAfterOpenCurlyBrace = createTypeChecker([
     ['+', hasDirectives],
-    ['+: node.body.length', Boolean],
+    ['+: node.body.length -> +'],
 ]);
 
 const isLinebreakAfterDirectives = createTypeChecker([
-    ['-: node.body.length -> !', Boolean],
+    ['-: node.body.length -> -'],
     ['+', hasDirectives],
 ]);
 
@@ -45,7 +43,7 @@ export const BlockStatement = {
         maybe.indent.inc(!insideArray);
         write('{');
         
-        if (isNewLineAfterOpenCurlyBrace(path))
+        if (isNewlineAfterOpenCurlyBrace(path))
             write.newline();
         
         for (const directive of directives) {

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

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

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

@@ -38,6 +38,6 @@ export const ReturnStatement = {
 };
 
 const isJSXWithComment = createTypeChecker([
-    ['-: node.argument -> !JSXElement'],
-    ['+: node.argument.leadingComments ->', Boolean],
+    '-: node.argument -> !JSXElement',
+    '+: node.argument.leadingComments -> +',
 ]);

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

@@ -90,6 +90,6 @@ 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/parsers.js

@@ -30,7 +30,7 @@ export function parseTypeNames(typeNames) {
         }
         
         if (isArray(typeName)) {
-            tuples.push(typeName);
+            tuples.push(parseComparison(typeName));
             continue;
         }
         
@@ -45,3 +45,27 @@ export function parseTypeNames(typeNames) {
     
     return tuples;
 }
+
+const equal = (a) => (b) => b === a;
+const more = (a) => (b) => b > a;
+const less = (a) => (b) => b < a;
+const moreOrEqual = (a) => (b) => b >= a;
+const lessOrEqual = (a) => (b) => b <= a;
+
+const CMP = {
+    '=': equal,
+    '>': more,
+    '<': less,
+    '>=': moreOrEqual,
+    '<=': lessOrEqual,
+};
+
+function parseComparison(typeName) {
+    if (typeName.length === 3) {
+        const [result, comparison, value] = typeName;
+        
+        return [result, CMP[comparison](value)];
+    }
+    
+    return typeName;
+}

package/package.json

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