@putout/printer 18.7.3 → 18.7.5

package/ChangeLog

@@ -1,3 +1,16 @@
+2026.03.16, v18.7.5
+
+feature:
+- f0cb1bfa @putout/printer: BlockStatement: isCallInsideChain: simplify
+- 246851f5 @putout/printer: MemberExpression: simplify
+- 3fd6353a @putout/printer: MemberExpression: simplify
+- 2ddd2e69 @putout/printer: LogicalExpression: simplify
+
+2026.03.16, v18.7.4
+
+feature:
+- a03e0d22 @putout/printer: type-checker: comparison
+
 2026.03.15, v18.7.3
 
 feature:

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

@@ -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,11 +190,10 @@ 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],
 ]);
 

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 -> -'],
-    ['+: node.typeParameters.params.length', isLessThenTwo],
+    ['+: node.typeParameters.params.length', '<', 2],
 ]);
 
 const classVisitor = maybeDecorators((path, printer, semantics) => {

package/lib/tokenize/expressions/logical-expression/chain.js

@@ -1,14 +1,12 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
 
-const {
-    isLogicalExpression,
-    isReturnStatement,
-    isVariableDeclarator,
-} = types;
+const {isLogicalExpression} = types;
 
-export const isRootOk = (path) => {
-    return isReturnStatement(path) || isVariableDeclarator(path);
-};
+export const isRootOk = createTypeChecker([
+    '+: -> ReturnStatement',
+    '+: -> VariableDeclarator',
+]);
 
 export const chain = (path) => {
     const [downCount] = down(path);

package/lib/tokenize/expressions/logical-expression/logical-expression.js

@@ -1,38 +1,42 @@
 import {maybeParens} from '#maybe-parens';
+import {createTypeChecker} from '#type-checker';
 import {chain, isRootOk} from './chain.js';
 
+const condition = createTypeChecker([
+    '+: parentPath -> UnaryExpression',
+    '+: parentPath -> AwaitExpression',
+]);
+
 export const LogicalExpression = maybeParens({
-    condition(path) {
-        if (path.parentPath.isUnaryExpression())
-            return true;
-        
-        return path.parentPath.isAwaitExpression();
-    },
+    condition,
     print(path, {print, maybe}, semantics) {
+        const {operator} = path.node;
+        
         print('__left');
         
-        const needNewLine = isNewLine(path, semantics);
+        const needNewLine = isNewline(path, semantics);
         
         maybe.indent.inc(needNewLine);
         needNewLine ? print.breakline() : print.space();
         maybe.indent.dec(needNewLine);
         
-        print(path.node.operator);
+        print(operator);
         print.space();
         print('__right');
     },
 });
 
-function isNewLine(path, semantics) {
+const callWithRoot = (fn) => (path, {maxLogicalsInOneLine}) => {
     const [root, count] = chain(path);
     
-    if (!isRootOk(root))
+    if (!fn(root))
         return false;
     
-    if (count <= semantics.maxLogicalsInOneLine)
-        return false;
-    
-    const {operator} = path.node;
-    
-    return operator === '||' || operator === '&&';
-}
+    return count > maxLogicalsInOneLine;
+};
+
+const isNewline = createTypeChecker([
+    ['-: -> !', callWithRoot(isRootOk)],
+    ['+: node.operator ->', '=', '||'],
+    ['+: node.operator ->', '=', '&&'],
+]);

package/lib/tokenize/expressions/member-expression/is-looks-like-chain.js

@@ -1,20 +1,49 @@
 import {types} from '@putout/babel';
-import {satisfy} from '#is';
+import {createTypeChecker} from '#type-checker';
 import {chain} from './chain.js';
 
+const hasPropertyWithComment = (properties) => {
+    return properties.find(hasComment);
+};
+
+const isPathGet = ([property]) => {
+    return isCallExpression(property, {
+        name: 'get',
+    });
+};
+
 const {
-    isUnaryExpression,
     isIfStatement,
     isCallExpression,
     isIdentifier,
 } = types;
 
-const isArgOfCall = (path) => path.parentPath?.isCallExpression() && path.parentPath.get('arguments.0') === path;
+const isPathFirstArg = ({node, parentPath}) => {
+    const [first] = parentPath.node.arguments;
+    return node === first;
+};
+
+function isPathLastArg({node, parentPath}) {
+    const last = parentPath.node.arguments.at(-1);
+    return node === last;
+}
+
+const isFirstArgOfCall = createTypeChecker([
+    ['-: parentPath -> !CallExpression'],
+    ['+', isPathFirstArg],
+]);
+
+const isLastArgInCall = createTypeChecker([
+    ['-: parentPath -> !CallExpression'],
+    ['+', isPathLastArg],
+]);
+
 const isCall = (a) => a.type === 'CallExpression';
 
-const isExcludedFromChain = satisfy([
-    isUnaryExpression,
-    isIfStatement,
+const callWithRoot = (fn) => (a, {root}) => fn(root);
+const isExcludedFromChain = createTypeChecker([
+    '+: -> UnaryExpression',
+    '+: -> IfStatement',
 ]);
 
 const hasComment = ({type}) => type === 'CommentLine';
@@ -32,51 +61,38 @@ const isInsideMemberCall = (path) => {
     return isCallExpression(path.parentPath.parentPath);
 };
 
-function isLastArgInCall(path) {
-    const {parentPath} = path;
-    
-    if (!isCallExpression(parentPath))
-        return false;
-    
-    return path === parentPath.get('arguments').at(-1);
-}
+const callWithProperties = (fn) => (a, {properties}) => fn(properties);
+const isFindUpIf = (path) => path.find(isIfUp);
 
-export const isLooksLikeChain = (path) => {
-    const [root, properties] = chain(path);
-    
-    if (isInsideMemberCall(path))
-        return false;
-    
-    if (isExcludedFromChain(root))
-        return false;
-    
-    if (isPathGet(properties))
-        return false;
-    
-    if (properties.find(hasComment))
-        return true;
-    
-    if (path.find(isIfUp))
-        return false;
-    
+const checkCallsCount = (path, {properties}) => {
     const calls = properties.filter(isCall);
     const [firstCall] = calls;
     
     if (calls.length === 2 && !firstCall.name)
         return false;
     
-    if (isArgOfCall(path))
-        return false;
-    
     return calls.length > 1;
 };
 
-const isPathGet = ([property]) => {
-    return isCallExpression(property, {
-        name: 'get',
+export const isLooksLikeChain = (path) => {
+    const [root, properties] = chain(path);
+    
+    return isLikeChain(path, {
+        root,
+        properties,
     });
 };
 
+const isLikeChain = createTypeChecker([
+    ['-', isInsideMemberCall],
+    ['-', callWithRoot(isExcludedFromChain)],
+    ['-', callWithProperties(isPathGet)],
+    ['+', callWithProperties(hasPropertyWithComment)],
+    ['-', isFindUpIf],
+    ['-', isFirstArgOfCall],
+    ['+', checkCallsCount],
+]);
+
 const isIfUp = (path) => {
     const ifPath = path.find(isIfStatement);
     let is = false;

package/lib/tokenize/expressions/member-expression/member-expressions.js

@@ -22,7 +22,6 @@ export const MemberExpression = maybeParens({
         const property = path.get('property');
         
         const {computed} = path.node;
-        
         const isChain = isLooksLikeChain(path);
         
         traverse(object);

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

@@ -6,16 +6,14 @@ 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 -> +'],
 ]);
@@ -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/block-statement/is-call-inside-chain.js

@@ -1,12 +1,8 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
 import {isLooksLikeChain} from '../../expressions/member-expression/is-looks-like-chain.js';
 
-const {
-    isReturnStatement,
-    isExpressionStatement,
-    isMemberExpression,
-    isCallExpression,
-} = types;
+const {isCallExpression} = types;
 
 export const isCallInsideChain = (path) => {
     if (!isCallExpression(path.parentPath.parentPath))
@@ -27,21 +23,13 @@ export const isCallInsideChain = (path) => {
     return isLooksLikeChain(calleeMember);
 };
 
-function isTopMemberInsideCall(path) {
-    if (!isMemberExpression(path))
-        return false;
-    
-    return isExpressionStatement(path.parentPath.parentPath);
-}
+const isTopMemberInsideCall = createTypeChecker([
+    '-: -> !MemberExpression',
+    '+: parentPath.parentPath -> ExpressionStatement',
+]);
 
-function isTopCall(path) {
-    if (!isCallExpression(path))
-        return false;
-    
-    const {parentPath} = path;
-    
-    if (isReturnStatement(parentPath))
-        return true;
-    
-    return isExpressionStatement(parentPath);
-}
+const isTopCall = createTypeChecker([
+    '-: -> !CallExpression',
+    '+: parentPath -> ReturnStatement',
+    '+: parentPath -> ExpressionStatement',
+]);

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

@@ -93,4 +93,3 @@ const isNewlineAfterColon = createTypeChecker([
     '-: node.consequent.length -> -',
     '+: node.consequent.0 -> !BlockStatement',
 ]);
-

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

@@ -1,14 +1,17 @@
 const isFn = (a) => typeof a === 'function';
 const isString = (a) => typeof a === 'string';
+const maybeNot = (not, a) => not ? !a : a;
 
 export const equal = (not, a, b) => {
+    if (!a)
+        return maybeNot(not, false);
+    
+    const {type} = a;
+    
     if (!isString(b))
         return false;
     
-    if (not)
-        return a !== b;
-    
-    return a === b;
+    return maybeNot(not, type === b);
 };
 
 export const maybeCall = (fn, not, a, options) => {

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/lib/tokenize/type-checker/type-checker.js

@@ -37,7 +37,7 @@ export const createTypeChecker = (typeNames, overrides = {}) => {
             if (selector)
                 currentPath = jessy(selector, path);
             
-            if (currentPath && equal(not, currentPath.type, typeName))
+            if (equal(not, currentPath, typeName))
                 return [index, result];
             
             if (maybeCall(typeName, not, currentPath, options))

package/package.json

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