@putout/printer 18.7.4 → 18.7.5

package/ChangeLog

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

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

@@ -308,4 +308,3 @@ export const isIndentBeforeElement = createTypeChecker([
     ['+: -> SpreadElement'],
     ['+: -> !ObjectExpression'],
 ]);
-

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/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/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/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.4",
+  "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",