@putout/printer 18.0.16 → 18.1.1

package/ChangeLog

@@ -1,3 +1,24 @@
+2026.03.06, v18.1.1
+
+feature:
+- ba26d34 @putout/printer: ExpressionStatement: isBreakline
+
+2026.03.06, v18.1.0
+
+feature:
+- 604e849 @putout/printer: ArrayExpression: long identifier: improve support
+- bdd07e7 @putout/printer: isMultiLine: siplify
+- 945a833 @putout/printer: ArrayExpression: newline: isCoupleLines
+- 2ca2751 @putout/printer: ArrayExpression: newline: isStringsInsideArray
+- 488eb71 @putout/printer: ArrayExpression: newline: isSimpleAndObject
+- 246f9df @putout/printer: ArrayExpression: newline: isIdentifierAndString
+- 56637d1 @putout/printer: ArrayExpression: newline: isStringAndIdentifier
+- caa4682 @putout/printer: ArrayExpression: newline: isStringAndIdentifier
+- 0e9dc1d @putout/printer: ArrayExpression: newline: isMultiline: simplify
+- 103ad2e @putout/printer: ExpressionStatement: isBreakline
+- 04c19c3 @putout/printer: ExpressionStatement: isNextToAssignmentCall: simplify
+- 4bcbd61 @putout/printer: ExpressionStatement: isNextStatementWithBlockComment: simplify
+
 2026.03.06, v18.0.16
 
 feature:

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

@@ -77,7 +77,6 @@ const isInsideOneElementArray = ({parentPath}) => parentPath.node.elements.lengt
 export const ArrayExpression = {
     beforeIf(path) {
         const {parentPath} = path;
-        const {elements} = path.node;
         
         if (!parentPath.isArrayExpression())
             return false;
@@ -85,10 +84,10 @@ export const ArrayExpression = {
         if (isCoupleLines(parentPath))
             return false;
         
-        if (isStringAndIdentifier(elements) && isInsideOneElementArray(path))
+        if (isStringAndIdentifier(path) && isInsideOneElementArray(path))
             return true;
         
-        return isIdentifierAndIdentifier(elements);
+        return isIdentifierAndIdentifier(path);
     },
     before(path, {print}) {
         print.breakline();
@@ -110,7 +109,6 @@ export const ArrayExpression = {
         maybe.indent.inc(indented && shouldIncreaseIndent);
         
         const isNewLine = isMultiLine(path, {
-            elements,
             maxElementsInOneLine,
             maxElementLengthInOneLine,
         });
@@ -148,7 +146,7 @@ export const ArrayExpression = {
         
         const parentElements = path.parentPath.get('elements');
         
-        if (isInsideArray(path) && isStringAndArray(parentElements)) {
+        if (isInsideArray(path) && isStringAndArray(path.parentPath)) {
             const parentCountTwo = parentElements.length === 2;
             const isHideIdent = !isAroundStrings(path) || parentCountTwo;
             
@@ -159,7 +157,7 @@ export const ArrayExpression = {
             maybe.indent(elements.length && isNewLine);
         }
         
-        if (isSimpleAndNotEmptyObject(elements) && !isSpreadElement(elements.at(-1)) && !isCallExpression(elements.at(-1))) {
+        if (isSimpleAndNotEmptyObject(path) && !isSpreadElement(elements.at(-1)) && !isCallExpression(elements.at(-1))) {
             print(',');
             print.breakline();
         }
@@ -168,7 +166,6 @@ export const ArrayExpression = {
     },
     afterIf(path) {
         const {parentPath} = path;
-        const {elements} = path.node;
         
         if (!parentPath.isArrayExpression())
             return false;
@@ -176,10 +173,10 @@ export const ArrayExpression = {
         if (isCoupleLines(parentPath))
             return false;
         
-        if (isStringAndIdentifier(elements) && isInsideOneElementArray(path))
+        if (isStringAndIdentifier(path) && isInsideOneElementArray(path))
             return true;
         
-        return isIdentifierAndIdentifier(elements);
+        return isIdentifierAndIdentifier(path);
     },
     after(path, {print, indent}) {
         indent.dec();

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

@@ -11,10 +11,69 @@ import {
     isSimpleAndNotEmptyObject,
     isInsideCall,
 } from '#is';
+import {isInsideArray} from './indent.js';
+import {isInsideForOf} from '../object-pattern/is.js';
+
+const isLastArg = ({parentPath}) => !parentPath.isCallExpression();
+const isParentProperty = (path) => path.find(isObjectProperty);
+
+const isNumbersArray = createTypeChecker([
+    ['-: node.elements', isNumbers],
+    ['-', isInsideForOf],
+    ['-: -> !', isLastArg],
+    ['+: -> !', isParentProperty],
+]);
+
+const isStringAndString = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isStringLiteral(a) && isStringLiteral(b);
+};
+
+const isStringsInsideArray = createTypeChecker([
+    ['-: -> !', isStringAndString],
+    ['-: -> !', isInsideArray],
+    '+: parentPath.node.elements.0 -> ArrayExpression',
+]);
+
+const isTwoSimplesInsideObjectProperty = (path) => {
+    const {node, parentPath} = path;
+    
+    const {elements} = node;
+    const {length} = elements;
+    const [a, b] = elements;
+    
+    if (length > 2)
+        return false;
+    
+    if (!parentPath.isObjectProperty())
+        return false;
+    
+    if (!isStringLiteral(a) || !isStringLiteral(b))
+        return false;
+    
+    return !isCoupleLines(path);
+};
+
+const isShortTwoSimplesInsideCall = (path, {maxElementsInOneLine}) => {
+    const {node, parentPath} = path;
+    
+    const {elements} = node;
+    const {length} = elements;
+    const [a, b] = elements;
+    
+    if (!parentPath.isCallExpression())
+        return false;
+    
+    if (!isStringLiteral(a) || !isStringLiteral(b))
+        return false;
+    
+    return length < maxElementsInOneLine;
+};
 
 const {
     isObjectExpression,
-    isArrayExpression,
     isObjectProperty,
     isCallExpression,
     isAwaitExpression,
@@ -23,11 +82,14 @@ const {
     isStringLiteral,
     isSpreadElement,
     isIdentifier,
+    isNumericLiteral,
 } = types;
 
 const {round} = Math;
 
-const isOneSpread = (elements) => {
+const isOneSpread = (path) => {
+    const {elements} = path.node;
+    
     if (elements.length > 1)
         return false;
     
@@ -36,19 +98,38 @@ const isOneSpread = (elements) => {
     return isSpreadElement(first);
 };
 
-const isSimpleAndCall = ([a, b]) => {
+const isSimpleAndCall = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
     if (!isSimple(a))
         return;
     
     return isCallExpression(b) || isAwaitExpression(b);
 };
 
-const isBooleanAndSimple = ([a, b]) => isBooleanLiteral(a) && isSimple(b);
+const isBooleanAndSimple = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isBooleanLiteral(a) && isSimple(b);
+};
+
 const isBooleanAndObject = ([a, b]) => isBooleanLiteral(a) && isObjectExpression(b);
-const isNullAndSimple = ([a, b]) => isNullLiteral(a) && isSimple(b);
-const isSimpleAndObject = ([a, b]) => isSimple(a) && isObjectExpression(b);
-const ONE_LINE = false;
-const MULTI_LINE = true;
+
+const isNullAndSimple = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isNullLiteral(a) && isSimple(b);
+};
+
+const isSimpleAndObject = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isSimple(a) && isObjectExpression(b);
+};
 
 const isSiblingIsArray = (path) => {
     if (path.getNextSibling().isArrayExpression())
@@ -70,13 +151,22 @@ const isMoreThenMaxLiteralLength = (path, {maxElementLengthInOneLine}) => {
     return first.value.length > maxElementLengthInOneLine;
 };
 
+const isMoreThenMaxIdentifierLength = (path) => {
+    const [first] = path.node.elements;
+    
+    return isIdentifier(first);
+};
+
 const isMoreThenMaxElementLengthInOneLine = createTypeChecker([
     ['-', isEmptyArray],
     ['-: -> !', isInsideCall],
     ['+', isMoreThenMaxLiteralLength],
+    ['+', isMoreThenMaxIdentifierLength],
 ]);
 
-function isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine) {
+function isMaxElementLengthInOneLine(path, {maxElementLengthInOneLine}) {
+    const elements = path.get('elements');
+    
     if (elements.length > 1)
         return false;
     
@@ -88,125 +178,55 @@ function isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine) {
     return first.node.name.length < maxElementLengthInOneLine;
 }
 
-export const isMultiLine = (path, {elements, maxElementsInOneLine, maxElementLengthInOneLine}) => {
-    const [first] = elements;
-    
-    if (isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine))
-        return ONE_LINE;
-    
-    if (isMoreThenMaxElementLengthInOneLine(path, {elements, maxElementLengthInOneLine}))
-        return MULTI_LINE;
-    
-    if (elements.length > maxElementsInOneLine && isStringLiteral(first))
-        return MULTI_LINE;
-    
-    if (elements.length > 3 && !isObjectExpression(first))
-        return MULTI_LINE;
-    
-    if (isSimpleAndNotEmptyObject(elements))
-        return MULTI_LINE;
-    
-    if (isOneSimple(path))
-        return ONE_LINE;
-    
-    if (isOneSpread(elements))
-        return ONE_LINE;
-    
-    if (elements.length === 2 && isIdentifierAndIdentifier(elements))
-        return ONE_LINE;
-    
-    if (isCallInsideArrow(path))
-        return ONE_LINE;
-    
-    if (isIncreaseIndent(path))
-        return ONE_LINE;
-    
-    if (isInsideLoop(path))
-        return ONE_LINE;
-    
-    if (isBooleanAndSimple(elements))
-        return ONE_LINE;
-    
-    if (isNullAndSimple(elements))
-        return ONE_LINE;
-    
-    if (isSimpleAndCall(elements))
-        return ONE_LINE;
-    
-    if (isShortTwoSimplesInsideCall(path, maxElementsInOneLine))
-        return ONE_LINE;
-    
-    if (isTwoStringsDifferentLength(elements))
-        return ONE_LINE;
-    
-    if (isTwoSimplesInsideObjectProperty(path))
-        return ONE_LINE;
-    
-    if (isStringAndArray(elements) && elements.length < 3)
-        return ONE_LINE;
-    
-    if (isStringAndMember(elements))
-        return ONE_LINE;
-    
-    if (isStringAndIdentifier(elements))
-        return ONE_LINE;
-    
-    if (isIdentifierAndString(elements))
-        return ONE_LINE;
-    
-    if (isSimpleAndObject(elements))
-        return ONE_LINE;
-    
-    if (isStringAndString(elements) && path.parentPath.isArrayExpression() && isArrayExpression(path.parentPath.node.elements[0]))
-        return ONE_LINE;
-    
-    if (isSiblingIsArray(path))
-        return ONE_LINE;
-    
-    if (tooLong(path) || isCoupleLines(path) || !isNumbers(elements) && !isForOf(path) && isLastArg(path) && !isParentProperty(path))
-        return MULTI_LINE;
-    
-    return ONE_LINE;
+const isElementsMoreThenMax = (path, {maxElementsInOneLine}) => {
+    const {elements} = path.node;
+    return elements.length > maxElementsInOneLine;
 };
 
-const isForOf = ({parentPath}) => parentPath.isForOfStatement();
+const isElementsMoreThenThree = (path) => {
+    const {elements} = path.node;
+    return elements.length > 3;
+};
 
-const isStringAndString = ([a, b]) => isStringLiteral(a) && isStringLiteral(b);
+const isElementsMoreThenThreeWithNotFirstObject = createTypeChecker([
+    '-: node.elements.0 -> ObjectExpression',
+    isElementsMoreThenThree,
+]);
 
-const isShortTwoSimplesInsideCall = (path, maxElementsInOneLine) => {
-    const {node, parentPath} = path;
-    
-    const {elements} = node;
-    const {length} = elements;
-    const [a, b] = elements;
-    
-    if (!parentPath.isCallExpression())
-        return false;
-    
-    if (!isStringLiteral(a) || !isStringLiteral(b))
-        return false;
-    
-    return length < maxElementsInOneLine;
-};
+const isElementsMoreThenMaxWithFirstString = createTypeChecker([
+    '-: node.elements.0 -> !StringLiteral',
+    isElementsMoreThenMax,
+]);
 
-const isTwoSimplesInsideObjectProperty = (path) => {
-    const {node, parentPath} = path;
-    
-    const {elements} = node;
-    const {length} = elements;
-    const [a, b] = elements;
-    
-    if (length > 2)
-        return false;
-    
-    if (!parentPath.isObjectProperty())
-        return false;
-    
-    if (!isStringLiteral(a) || !isStringLiteral(b))
-        return false;
-    
-    return !isCoupleLines(path);
-};
+export const isMultiLine = createTypeChecker([
+    ['-', isMaxElementLengthInOneLine],
+    isMoreThenMaxElementLengthInOneLine,
+    isElementsMoreThenMaxWithFirstString,
+    isElementsMoreThenThreeWithNotFirstObject,
+    isSimpleAndNotEmptyObject,
+    ['-', isOneSimple],
+    ['-', isOneSpread],
+    ['-', isIdentifierAndIdentifier],
+    ['-', isCallInsideArrow],
+    ['-', isIncreaseIndent],
+    ['-', isInsideLoop],
+    ['-', isBooleanAndSimple],
+    ['-', isNullAndSimple],
+    ['-', isSimpleAndCall],
+    ['-', isShortTwoSimplesInsideCall],
+    ['-', isTwoStringsDifferentLength],
+    ['-', isTwoSimplesInsideObjectProperty],
+    ['-', isStringAndArray],
+    ['-', isStringAndMember],
+    ['-', isStringAndIdentifier],
+    ['-', isIdentifierAndString],
+    ['-', isSimpleAndObject],
+    ['-', isSiblingIsArray],
+    ['-', isStringsInsideArray],
+    tooLong,
+    isCoupleLines,
+    isNumbersArray,
+]);
 
 function isOneSimple(path) {
     const elements = path.get('elements');
@@ -228,17 +248,18 @@ function isOneSimple(path) {
     return first.isMemberExpression();
 }
 
-function isTwoStringsDifferentLength(strings) {
-    const [a, b] = strings;
+function isTwoStringsDifferentLength(path) {
+    const {elements} = path.node;
+    const [a, b] = elements;
     
-    if (strings.length > 2)
+    if (elements.length > 2)
         return false;
     
-    if (!a?.isStringLiteral() || !b?.isStringLiteral())
+    if (!isStringLiteral(a) || !isStringLiteral(b))
         return false;
     
-    const aLength = a.node.value.length;
-    const bLength = b.node.value.length;
+    const aLength = a.value.length;
+    const bLength = b.value.length;
     
     return round(bLength / aLength) > 2;
 }
@@ -275,17 +296,13 @@ function isCallInsideArrow(path) {
 
 function isNumbers(elements) {
     for (const element of elements) {
-        if (element.isNumericLiteral())
+        if (isNumericLiteral(element))
             return true;
     }
     
     return false;
 }
 
-const isLastArg = ({parentPath}) => !parentPath.isCallExpression();
-
-const isParentProperty = (path) => path.find(isObjectProperty);
-
 export function isIncreaseIndent(path) {
     const elements = path.get('elements');
     

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

@@ -12,7 +12,10 @@ 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,10 @@ 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

@@ -91,7 +91,10 @@ export function isCoupleLines(path) {
 
 export const exists = (a) => a.node;
 
-export function isStringAndIdentifier([a, b]) {
+export function isStringAndIdentifier(path) {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
     return isStringLiteral(a) && isIdentifier(b);
 }
 
@@ -107,7 +110,8 @@ const checkObject = (elements) => {
     return a.node.properties.length;
 };
 
-export const isSimpleAndNotEmptyObject = (elements) => {
+export const isSimpleAndNotEmptyObject = (path) => {
+    const elements = path.get('elements');
     const [a] = elements;
     
     const simpleTypes = [
@@ -124,20 +128,44 @@ export const isSimpleAndNotEmptyObject = (elements) => {
     return checkObject(elements);
 };
 
-export const isIdentifierAndIdentifier = ([a, b]) => {
+export const isIdentifierAndIdentifier = (path) => {
+    const {elements} = path.node;
+    
+    if (elements.length !== 2)
+        return;
+    
+    const [a, b] = elements;
+    
     return isIdentifier(a) && isIdentifier(b);
 };
 
-export const isStringAndMember = ([a, b]) => isStringLiteral(a) && isMemberExpression(b);
-export const isIdentifierAndString = ([a, b]) => isIdentifier(a) && isStringLiteral(b);
-export const isStringAndArray = ([a, b]) => {
+export const isStringAndMember = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isStringLiteral(a) && isMemberExpression(b);
+};
+export const isIdentifierAndString = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isIdentifier(a) && isStringLiteral(b);
+};
+export const isStringAndArray = (path) => {
+    const elements = path.get('elements');
+    
+    if (elements.length !== 2)
+        return false;
+    
+    const [a, b] = elements;
+    
     if (!isStringLiteral(a))
         return false;
     
     if (!isArrayExpression(b))
         return false;
     
-    return !isStringAndIdentifier(b.node.elements);
+    return !isStringAndIdentifier(b);
 };
 
 const isIfOrStatement = (a) => isIfStatement(a) || isStatement(a);

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

@@ -4,7 +4,6 @@ import {
     isNext,
     isLast,
     isNewlineBetweenSiblings,
-    satisfy,
     noTrailingComment,
     hasTrailingComment,
     isCoupleLines,
@@ -19,27 +18,33 @@ import {
 import {afterIf} from './after-if.js';
 import {beforeIf} from './before-if.js';
 
-const isCommentBlock = (a) => a?.type === 'CommentBlock';
-const isBreakline = createTypeChecker([
+const {isIfStatement} = types;
+
+const isCallInsideExpression = createTypeChecker([
+    '-: -> !ExpressionStatement',
+    '+: node.expression -> CallExpression',
+]);
+
+const isNextToAssignmentCall = createTypeChecker([
+    '-: node.expression -> AssignmentExpression',
+    ['+', getNext(isCallInsideExpression)],
+]);
+
+const isBreaklineAfter = createTypeChecker([
     ['-: -> !', hasTrailingComment],
     ['-: -> !', isLast],
     ['+', isCoupleLines],
 ]);
 
-const {
-    isCallExpression,
-    isExpressionStatement,
-    isAssignmentExpression,
-} = types;
-
-const isNextIf = (path) => path
-    .getNextSibling()
-    .isIfStatement();
+const isNextStatementWithBlockComment = createTypeChecker([
+    '-: node.expression -> !CallExpression',
+    '-: node.expression.arguments.0 -> !CallExpression',
+    '+: node.trailingComments.0 -> CommentBlock',
+]);
 
-const shouldBreakline = satisfy([
+const isBreakline = createTypeChecker([
     isNewlineBetweenSiblings,
-    isNotLastBody,
-    isNextIf,
+    getNext(isIfStatement),
 ]);
 
 const isIndent = createTypeChecker([
@@ -54,20 +59,20 @@ 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;
         
-        if (!insideReturn && shouldBreakline(path)) {
+        if (isBreakline(path)) {
             print.newline();
             maybe.indent(isIndent(path));
             store(true);
@@ -75,7 +80,7 @@ export const ExpressionStatement = {
     },
     afterIf,
     after(path, {print, maybe, store}) {
-        maybe.print.breakline(isBreakline(path));
+        maybe.print.breakline(isBreaklineAfter(path));
         
         if (isInsideReturn(path))
             return;
@@ -85,42 +90,4 @@ export const ExpressionStatement = {
         maybe.markAfter(store(), path);
     },
 };
-ExpressionStatement.printLeadingCommentLine = printLeadingCommentLine;
-ExpressionStatement.printLeadingCommentBlock = printLeadingCommentBlock;
-
-function isNotLastBody(path) {
-    return path.parentPath.get('body') === path;
-}
-
-function isNextToAssignmentCall(path) {
-    if (isAssignmentExpression(path.node.expression))
-        return false;
-    
-    const nextPath = path.getNextSibling();
-    
-    if (!isExpressionStatement(nextPath))
-        return false;
-    
-    const {expression} = nextPath.node;
-    
-    return isCallExpression(expression);
-}
-
-function isNextStatementWithBlockComment(path) {
-    const {expression} = path.node;
-    
-    if (!isCallExpression(expression))
-        return false;
-    
-    if (!isCallExpression(expression.arguments[0]))
-        return false;
-    
-    return hasTrailingBlock(path);
-}
 
-function hasTrailingBlock(path) {
-    const {trailingComments} = path.node;
-    const [first] = trailingComments;
-    
-    return isCommentBlock(first);
-}

package/package.json

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