@putout/printer 18.0.14 → 18.0.16

package/ChangeLog

@@ -1,3 +1,23 @@
+2026.03.06, v18.0.16
+
+feature:
+- 2a81cf2 @putout/printer: ExpressionStatement: rm is-inside-assign-next-assign-function
+- 17d19f2 @putout/printer: ExpressionStatement: rm not
+- 1c07e30 @putout/printer: ExpressionStatement: isBreakline: add
+- 15f67f0 @putout/printer: ExpressionStatement: afterIf: move out
+- c6783ee @putout/printer: ExpressionStatement: hasTrailingCommentNotCoupleLines
+- 8e08572 @putout/printer: ExpressionStatement: isTopParentLast: simplify
+- fe1b0ca @putout/printer: ExpressionStatement: isTopParentLast
+- b84b9a6 @putout/printer: ExpressionStatement: isIndent
+- d4d0106 @putout/printer: ExpressionStatement: beforeIf: simplify
+- 9a4721a @putout/printer: ExpressionStatement: afterIf: simplify
+- a9d2cf8 @putout/printer: ExpressionStatement: isBeforeElse: simplify
+
+2026.03.06, v18.0.15
+
+feature:
+- 22d510e @putout/printer: ObjectExpression: isLogicalArgument
+
 2026.03.06, v18.0.14
 
 feature:

package/lib/tokenize/expressions/function/function-declaration.js

@@ -1,7 +1,11 @@
 import {types} from '@putout/babel';
 import {printParams} from '#print-params';
 import {markAfter} from '#mark';
-import {isNext, isNextParent} from '#is';
+import {
+    getNext,
+    isNext,
+    isNextParent,
+} from '#is';
 import {createTypeChecker} from '#type-checker';
 
 const {
@@ -12,8 +16,6 @@ const {
 
 const hasFnBody = ({node}) => node.body.body.length;
 
-const getNext = (fn) => (path) => fn(path.getNextSibling());
-
 const isIndentAfter = createTypeChecker([
     ['+', getNext(isFunctionDeclaration)],
     ['+', isNext],

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

@@ -32,10 +32,12 @@ const notLastArgInsideCall = (path) => {
 const hasNoProperties = (path) => !path.node.properties.length;
 const hasValue = (path) => path.node.properties[0].value;
 
-const {isMemberExpression} = types;
-
-const isLogical = (path) => path.get('argument').isLogicalExpression();
+const {
+    isMemberExpression,
+    isLogicalExpression,
+} = types;
 
+const isLogicalArgument = (path) => isLogicalExpression(path.node.argument);
 const isParens = createTypeChecker([isInsideBody, isInsideExpression]);
 const getCallee = (fn) => (a) => fn(a.get('callee'));
 
@@ -97,7 +99,7 @@ export const ObjectExpression = (path, printer, semantics) => {
     
     for (const [index, property] of properties.entries()) {
         if (property.isSpreadElement()) {
-            const logical = isLogical(property);
+            const logical = isLogicalArgument(property);
             
             if (noLeadingComment(property))
                 maybe.indent(length > 1 || logical || manyLines);

package/lib/tokenize/is.js

@@ -28,6 +28,8 @@ export const isInsideExpression = ({parentPath}) => isExpressionStatement(parent
 export const isInsideTSModuleBlock = ({parentPath}) => isTSModuleBlock(parentPath);
 
 export const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
+export const isInsideReturn = ({parentPath}) => parentPath.isReturnStatement();
+export const getNext = (fn) => (path) => fn(path.getNextSibling());
 
 export const isNext = (path) => {
     const next = path.getNextSibling();

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

@@ -0,0 +1,52 @@
+import {createTypeChecker} from '#type-checker';
+import {
+    hasTrailingComment,
+    isCoupleLines,
+    isInsideBlock,
+    isLast,
+    isNext,
+    isParentLast,
+    satisfy,
+} from '#is';
+
+function isNotLastOrParentLast(path) {
+    return !isLast(path) && !isParentLast(path);
+}
+
+const isNextUp = (path) => path.findParent(isNext);
+
+const isTopParentLast = createTypeChecker([
+    '-: parentPath -> !IfStatement',
+    '-: parentPath.parentPath -> !IfStatement',
+    '-: parentPath.parentPath.parentPath -> !IfStatement',
+    ['+: parentPath.parentPath.parentPath', isLast],
+]);
+
+const satisfyAfter = satisfy([
+    isNotLastOrParentLast,
+    isInsideBlock,
+    isNext,
+    isNextUp,
+]);
+
+const isPathIsConsequent = ({node, parentPath}) => node !== parentPath.node.consequent;
+
+const isBeforeElse = createTypeChecker([
+    '-: parentPath -> !IfStatement',
+    ['-:', isPathIsConsequent],
+    ['+: parentPath.node.alternate', Boolean],
+]);
+
+const hasTrailingCommentNotCoupleLines = createTypeChecker([
+    ['-: -> !', hasTrailingComment],
+    ['+: -> !', isCoupleLines],
+]);
+
+export const afterIf = createTypeChecker([
+    ['-', isTopParentLast],
+    ['-', hasTrailingCommentNotCoupleLines],
+    ['+', satisfyAfter],
+    ['+', isBeforeElse],
+    ['-: -> !', hasTrailingComment],
+    ['+', isLast],
+]);

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

@@ -0,0 +1,7 @@
+import {createTypeChecker} from '#type-checker';
+import {isInsideLabel, isInsideReturn} from '#is';
+
+export const beforeIf = createTypeChecker([
+    ['-', isInsideReturn],
+    ['+: -> !', isInsideLabel],
+]);

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

@@ -1,23 +1,30 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
 import {
     isNext,
     isLast,
-    isInsideBlock,
-    isParentLast,
     isNewlineBetweenSiblings,
     satisfy,
     noTrailingComment,
     hasTrailingComment,
     isCoupleLines,
-    isInsideLabel,
+    isInsideReturn,
+    getNext,
+    hasLeadingComment,
 } from '#is';
-import {isInsideAssignNextAssignFunction} from './is-inside-assign-next-assign-function.js';
 import {
     printLeadingCommentLine,
     printLeadingCommentBlock,
-} from './expression-statement-comments.js';
+} from './comments.js';
+import {afterIf} from './after-if.js';
+import {beforeIf} from './before-if.js';
 
 const isCommentBlock = (a) => a?.type === 'CommentBlock';
+const isBreakline = createTypeChecker([
+    ['-: -> !', hasTrailingComment],
+    ['-: -> !', isLast],
+    ['+', isCoupleLines],
+]);
 
 const {
     isCallExpression,
@@ -25,28 +32,6 @@ const {
     isAssignmentExpression,
 } = types;
 
-const not = (fn) => (...a) => !fn(...a);
-
-const isBeforeElse = (path) => {
-    if (!path.parentPath.isIfStatement())
-        return false;
-    
-    if (path !== path.parentPath.get('consequent'))
-        return false;
-    
-    return Boolean(path.parentPath.node.alternate);
-};
-
-const isInsideReturn = ({parentPath}) => parentPath.isReturnStatement();
-const notInsideReturn = not(isInsideReturn);
-
-const satisfyAfter = satisfy([
-    isNotLastOrParentLast,
-    isInsideBlock,
-    isNext,
-    isNextUp,
-]);
-
 const isNextIf = (path) => path
     .getNextSibling()
     .isIfStatement();
@@ -57,17 +42,23 @@ const shouldBreakline = satisfy([
     isNextIf,
 ]);
 
+const isIndent = createTypeChecker([
+    noTrailingComment,
+    isNextToAssignmentCall,
+    isNextStatementWithBlockComment,
+]);
+
+export const isIndentAfter = createTypeChecker([
+    '-: node.expression -> !AssignmentExpression',
+    ['+', getNext(hasLeadingComment)],
+]);
+
 export const ExpressionStatement = {
-    beforeIf(path) {
-        if (isInsideReturn(path))
-            return false;
-        
-        return !isInsideLabel(path);
-    },
+    beforeIf,
     before(path, {indent}) {
         indent();
     },
-    print(path, {print, maybe, store, indent}) {
+    print(path, {print, maybe, store}) {
         const insideReturn = isInsideReturn(path);
         
         print('__expression');
@@ -78,78 +69,29 @@ export const ExpressionStatement = {
         
         if (!insideReturn && shouldBreakline(path)) {
             print.newline();
-            
-            const condition = isNext(path)
-                && noTrailingComment(path)
-                || isNextToAssignmentCall(path)
-                || isNextStatementWithBlockComment(path);
-            
-            if (condition)
-                indent();
-            
+            maybe.indent(isIndent(path));
             store(true);
         }
     },
-    afterIf: (path) => {
-        if (satisfyAfter(path))
-            return true;
-        
-        if (hasTrailingComment(path) && isLast(path))
-            return true;
-        
-        return isBeforeElse(path);
-    },
-    after(path, {print, maybe, store, indent}) {
-        if (hasTrailingComment(path) && isLast(path) && isCoupleLines(path))
-            print.breakline();
-        
-        if (hasTrailingComment(path) && !isCoupleLines(path))
-            return;
+    afterIf,
+    after(path, {print, maybe, store}) {
+        maybe.print.breakline(isBreakline(path));
         
-        if (isTopParentLast(path))
+        if (isInsideReturn(path))
             return;
         
-        if (notInsideReturn(path)) {
-            if (isInsideAssignNextAssignFunction(path))
-                indent();
-            
-            print.newline();
-            maybe.markAfter(store(), path);
-        }
+        maybe.indent(isIndentAfter(path));
+        print.newline();
+        maybe.markAfter(store(), path);
     },
 };
 ExpressionStatement.printLeadingCommentLine = printLeadingCommentLine;
 ExpressionStatement.printLeadingCommentBlock = printLeadingCommentBlock;
 
-function isTopParentLast({parentPath}) {
-    if (!parentPath.isIfStatement())
-        return false;
-    
-    const nextParent = parentPath.parentPath;
-    
-    if (!nextParent.isIfStatement())
-        return false;
-    
-    const nextNext = nextParent.parentPath;
-    
-    if (!nextNext.isIfStatement())
-        return false;
-    
-    return isLast(nextNext);
-}
-
 function isNotLastBody(path) {
     return path.parentPath.get('body') === path;
 }
 
-function isNotLastOrParentLast(path) {
-    return !isLast(path) && !isParentLast(path);
-}
-
-function isNextUp(path) {
-    return path.findParent(isNext);
-}
-
 function isNextToAssignmentCall(path) {
     if (isAssignmentExpression(path.node.expression))
         return false;

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

@@ -1,4 +1,8 @@
-import {isInsideLabel, exists} from '#is';
+import {
+    isInsideLabel,
+    exists,
+    getNext,
+} from '#is';
 import {markAfter} from '#mark';
 
 export const ForStatement = {
@@ -36,9 +40,7 @@ export const ForStatement = {
         print('__body');
         maybe.indent.dec(is);
     },
-    afterIf(path) {
-        return exists(path.getNextSibling());
-    },
+    afterIf: getNext(exists),
     after(path, {print}) {
         print.linebreak();
         markAfter(path);

package/package.json

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

package/lib/tokenize/statements/expression-statement/is-inside-assign-next-assign-function.js

@@ -1,32 +0,0 @@
-import {types} from '@putout/babel';
-
-const {
-    isExpressionStatement,
-    isFunction,
-    isAssignmentExpression,
-} = types;
-
-export const isInsideAssignNextAssignFunction = (path) => {
-    const {expression} = path.node;
-    
-    if (!isAssignmentExpression(expression))
-        return false;
-    
-    const next = path.getNextSibling();
-    
-    if (isFunction(next) && next.node.leadingComments)
-        return true;
-    
-    if (!isExpressionStatement(next))
-        return false;
-    
-    const {leadingComments} = next.node;
-    
-    if (!leadingComments)
-        return false;
-    
-    if (!isAssignmentExpression(next.node.expression))
-        return false;
-    
-    return isFunction(next.node.expression.right);
-};