@putout/printer 18.1.0 → 18.1.2

package/ChangeLog

@@ -1,3 +1,16 @@
+2026.03.06, v18.1.2
+
+feature:
+- 5996fbf @putout/printer: TypeChecker: ->
+- 7001376 @putout/printer: ArrayExpression: beforeIf: move out
+- 2f22d1d @putout/printer: ArrayExpression: isSimpleBetweenObjects
+- 50166f4 @putout/printer: ArrayExpression: isSpaceAfterComma
+
+2026.03.06, v18.1.1
+
+feature:
+- ba26d34 @putout/printer: ExpressionStatement: isBreakline
+
 2026.03.06, v18.1.0
 
 feature:

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

@@ -1,4 +1,5 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
 import {
     isCoupleLines,
     isStringAndIdentifier,
@@ -6,6 +7,8 @@ import {
     isStringAndArray,
     isSimpleAndNotEmptyObject,
     isNextObject,
+    getNext,
+    isInsideArray,
 } from '#is';
 import {
     isIncreaseIndent,
@@ -13,14 +16,14 @@ import {
     isMultiLine,
 } from './newline.js';
 import {
-    isInsideArray,
     isArrayInsideArray,
     isArrayIndented,
 } from './indent.js';
+import {isObjectAfterSimple} from './is-object-after-simple.js';
 import {
-    isObjectAfterSimple,
-    isNextSimple,
-} from './is-object-after-simple.js';
+    beforeIf,
+    isInsideOneElementArray,
+} from './before-if.js';
 
 const {
     isObjectExpression,
@@ -60,35 +63,20 @@ const isSpreadBeforeObject = (a) => {
     return prev.get('argument').isCallExpression();
 };
 
-const isNextSimpleBetweenObjects = (a) => {
-    const next = a.getNextSibling();
-    const is = next.isSpreadElement() || next.isIdentifier() || next.isCallExpression();
-    
-    if (!is)
-        return true;
-    
-    return next
-        .getNextSibling()
-        .isObjectExpression();
-};
+const isSimpleBetweenObjects = createTypeChecker([
+    ['+', getNext(isObjectExpression)],
+    ['-', isSpreadElement],
+    ['-', isIdentifier],
+    ['+: -> !', isCallExpression],
+]);
 
-const isInsideOneElementArray = ({parentPath}) => parentPath.node.elements.length === 1;
+const isSpaceAfterComa = createTypeChecker([
+    getNext(isSimpleBetweenObjects),
+    '+: -> !ObjectExpression',
+]);
 
 export const ArrayExpression = {
-    beforeIf(path) {
-        const {parentPath} = path;
-        
-        if (!parentPath.isArrayExpression())
-            return false;
-        
-        if (isCoupleLines(parentPath))
-            return false;
-        
-        if (isStringAndIdentifier(path) && isInsideOneElementArray(path))
-            return true;
-        
-        return isIdentifierAndIdentifier(path);
-    },
+    beforeIf,
     before(path, {print}) {
         print.breakline();
     },
@@ -137,7 +125,7 @@ export const ArrayExpression = {
             if (!is && index < n) {
                 print(',');
                 
-                if (isNextSimpleBetweenObjects(element) || !(element.isObjectExpression() && isNextSimple(element)))
+                if (isSpaceAfterComa(element))
                     print.space();
             }
         }

package/lib/tokenize/expressions/array-expression/before-if.js

@@ -0,0 +1,24 @@
+import {createTypeChecker} from '#type-checker';
+import {
+    isCoupleLines,
+    isIdentifierAndIdentifier,
+    isInsideArray,
+    isStringAndIdentifier,
+} from '#is';
+
+export const isInsideOneElementArray = ({parentPath}) => {
+    const {elements} = parentPath.node;
+    return elements.length === 1;
+};
+
+const isStringAndIdentifierInsideOneElementArray = createTypeChecker([
+    ['-: -> !', isStringAndIdentifier],
+    ['+', isInsideOneElementArray],
+]);
+
+export const beforeIf = createTypeChecker([
+    ['-: -> !', isInsideArray],
+    ['-: parentPath ->', isCoupleLines],
+    isIdentifierAndIdentifier,
+    isStringAndIdentifierInsideOneElementArray,
+]);

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

@@ -1,5 +1,5 @@
 import {types} from '@putout/babel';
-import {isIndented} from '#is';
+import {isIndented, isInsideArray} from '#is';
 
 const {
     isStringLiteral,
@@ -8,8 +8,6 @@ const {
     isTemplateLiteral,
 } = types;
 
-export const isInsideArray = (path) => path.parentPath.isArrayExpression();
-
 const isObjectAfterString = ([first, second]) => {
     if (!first || !second)
         return false;

package/lib/tokenize/expressions/array-expression/is-object-after-simple.js

@@ -17,9 +17,3 @@ export const isObjectAfterSimple = (a) => {
     
     return SIMPLE_TYPES.includes(type);
 };
-
-export const isNextSimple = (a) => {
-    const {type} = a.getNextSibling();
-    
-    return SIMPLE_TYPES.includes(type);
-};

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

@@ -10,8 +10,8 @@ import {
     isIdentifierAndIdentifier,
     isSimpleAndNotEmptyObject,
     isInsideCall,
+    isInsideArray,
 } from '#is';
-import {isInsideArray} from './indent.js';
 import {isInsideForOf} from '../object-pattern/is.js';
 
 const isLastArg = ({parentPath}) => !parentPath.isCallExpression();

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

@@ -12,7 +12,11 @@ const {
 const isArgOfCall = (path) => path.parentPath?.isCallExpression() && path.parentPath.get('arguments.0') === path;
 const isCall = (a) => a.type === 'CallExpression';
 
-const isExcludedFromChain = satisfy([isUnaryExpression, isIfStatement]);
+const isExcludedFromChain = satisfy([
+    isUnaryExpression,
+    isIfStatement,
+]);
+
 const hasComment = ({type}) => type === 'CommentLine';
 
 const isInsideMemberCall = (path) => {

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

@@ -38,7 +38,12 @@ const {
 } = types;
 
 const isLogicalArgument = (path) => isLogicalExpression(path.node.argument);
-const isParens = createTypeChecker([isInsideBody, isInsideExpression]);
+
+const isParens = createTypeChecker([
+    isInsideBody,
+    isInsideExpression,
+]);
+
 const getCallee = (fn) => (a) => fn(a.get('callee'));
 
 const isMemberExpressionCallee = createTypeChecker([

package/lib/tokenize/is.js

@@ -24,6 +24,7 @@ export const isInsideBlock = (path) => isBlockStatement(path.parentPath);
 export const isInsideSwitchCase = (path) => isSwitchCase(path.parentPath);
 export const isInsideBody = ({node, parentPath}) => node === parentPath.node.body;
 export const isInsideExpression = ({parentPath}) => isExpressionStatement(parentPath);
+export const isInsideArray = (path) => isArrayExpression(path.parentPath);
 
 export const isInsideTSModuleBlock = ({parentPath}) => isTSModuleBlock(parentPath);
 

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

@@ -1,3 +1,4 @@
+import {types} from '@putout/babel';
 import {createTypeChecker} from '#type-checker';
 import {
     isNext,
@@ -17,6 +18,8 @@ import {
 import {afterIf} from './after-if.js';
 import {beforeIf} from './before-if.js';
 
+const {isIfStatement} = types;
+
 const isCallInsideExpression = createTypeChecker([
     '-: -> !ExpressionStatement',
     '+: node.expression -> CallExpression',
@@ -27,23 +30,22 @@ const isNextToAssignmentCall = createTypeChecker([
     ['+', getNext(isCallInsideExpression)],
 ]);
 
-const isNextStatementWithBlockComment = createTypeChecker([
-    '-: node.expression -> !CallExpression',
-    '-: node.expression.arguments.0 -> !CallExpression',
-    '+: node.trailingComments.0 -> CommentBlock',
-]);
-
 const isBreaklineAfter = createTypeChecker([
     ['-: -> !', hasTrailingComment],
     ['-: -> !', isLast],
     ['+', isCoupleLines],
 ]);
 
-const isNextIf = (path) => path
-    .getNextSibling()
-    .isIfStatement();
+const isNextStatementWithBlockComment = createTypeChecker([
+    '-: node.expression -> !CallExpression',
+    '-: node.expression.arguments.0 -> !CallExpression',
+    '+: node.trailingComments.0 -> CommentBlock',
+]);
 
-const isBreakline = createTypeChecker([isNewlineBetweenSiblings, isNextIf]);
+const isBreakline = createTypeChecker([
+    isNewlineBetweenSiblings,
+    getNext(isIfStatement),
+]);
 
 const isIndent = createTypeChecker([
     noTrailingComment,
@@ -57,15 +59,15 @@ export const isIndentAfter = createTypeChecker([
 ]);
 
 export const ExpressionStatement = {
+    printLeadingCommentLine,
+    printLeadingCommentBlock,
     beforeIf,
     before(path, {indent}) {
         indent();
     },
     print(path, {print, maybe, store}) {
-        const insideReturn = isInsideReturn(path);
-        
         print('__expression');
-        maybe.print(!insideReturn, ';');
+        maybe.print(!isInsideReturn(path), ';');
         
         if (!isNext(path))
             return;
@@ -88,5 +90,3 @@ export const ExpressionStatement = {
         maybe.markAfter(store(), path);
     },
 };
-ExpressionStatement.printLeadingCommentLine = printLeadingCommentLine;
-ExpressionStatement.printLeadingCommentBlock = printLeadingCommentBlock;

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

@@ -10,7 +10,7 @@ export const parseOperation = (operation) => {
     if (!command)
         return [parsedResult, '', ''];
     
-    const [selector, not] = command.split(' -> ');
+    const [selector, not] = command.split(/ ->\s?/);
     
     return [parsedResult, selector.trim(), not];
 };

package/package.json

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