@putout/printer 18.1.4 → 18.1.6

package/ChangeLog

@@ -1,3 +1,13 @@
+2026.03.07, v18.1.6
+
+feature:
+- b94489a @putout/printer: ArrayExpression: no new line when single element
+
+2026.03.07, v18.1.5
+
+feature:
+- 142e7b8 @putout/printer: is: getNext -> callWithNext
+
 2026.03.06, v18.1.4
 
 fix:

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

@@ -7,7 +7,7 @@ import {
     isStringAndArray,
     isSimpleAndNotEmptyObject,
     isNextObject,
-    getNext,
+    callWithNext,
     isInsideArray,
 } from '#is';
 import {
@@ -64,14 +64,14 @@ const isSpreadBeforeObject = (a) => {
 };
 
 const isSimpleBetweenObjects = createTypeChecker([
-    ['+', getNext(isObjectExpression)],
+    ['+', callWithNext(isObjectExpression)],
     ['-', isSpreadElement],
     ['-', isIdentifier],
     ['+: -> !', isCallExpression],
 ]);
 
 const isSpaceAfterComa = createTypeChecker([
-    getNext(isSimpleBetweenObjects),
+    callWithNext(isSimpleBetweenObjects),
     '+: -> !ObjectExpression',
 ]);
 

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

@@ -12,15 +12,11 @@ import {
     isInsideCall,
     isInsideArray,
 } from '#is';
-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],
+    ['-: node.elements -> !', isNumbers],
     ['+: -> !', isParentProperty],
 ]);
 
@@ -140,12 +136,11 @@ const isSiblingIsArray = (path) => {
         .isArrayExpression();
 };
 
-const isEmptyArray = (path) => !path.node.elements.length;
-
 const isMoreThenMaxLiteralLength = (path, {maxElementLengthInOneLine}) => {
-    const [first] = path.node.elements;
+    const {elements} = path.node;
+    const [first] = elements;
     
-    if (!first.value)
+    if (!isStringLiteral(first))
         return false;
     
     return first.value.length > maxElementLengthInOneLine;
@@ -167,28 +162,16 @@ const hasObjects = (path) => {
     return literals.length;
 };
 
+const isLessThenTwo = (a) => a < 2;
+
 const isMoreThenMaxElementLengthInOneLine = createTypeChecker([
-    ['-', isEmptyArray],
+    ['-: node.elements.length', isLessThenTwo],
     ['-: -> !', isInsideCall],
     ['-', hasObjects],
     ['+', isMoreThenMaxLiteralLength],
     ['+', isMoreThenMaxIdentifierLength],
 ]);
 
-function isMaxElementLengthInOneLine(path, {maxElementLengthInOneLine}) {
-    const elements = path.get('elements');
-    
-    if (elements.length > 1)
-        return false;
-    
-    const [first] = elements;
-    
-    if (!isIdentifier(first))
-        return false;
-    
-    return first.node.name.length < maxElementLengthInOneLine;
-}
-
 const isElementsMoreThenMax = (path, {maxElementsInOneLine}) => {
     const {elements} = path.node;
     return elements.length > maxElementsInOneLine;
@@ -210,9 +193,8 @@ const isElementsMoreThenMaxWithFirstString = createTypeChecker([
 ]);
 
 export const isMultiLine = createTypeChecker([
-    ['-', isMaxElementLengthInOneLine],
-    isMoreThenMaxElementLengthInOneLine,
-    isElementsMoreThenMaxWithFirstString,
+    ['+', isMoreThenMaxElementLengthInOneLine],
+    ['+', isElementsMoreThenMaxWithFirstString],
     isElementsMoreThenThreeWithNotFirstObject,
     isSimpleAndNotEmptyObject,
     ['-', isOneSimple],
@@ -236,7 +218,7 @@ export const isMultiLine = createTypeChecker([
     ['-', isStringsInsideArray],
     tooLong,
     isCoupleLines,
-    isNumbersArray,
+    ['-', isNumbersArray],
 ]);
 
 function isOneSimple(path) {

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

@@ -2,7 +2,7 @@ import {types} from '@putout/babel';
 import {printParams} from '#print-params';
 import {markAfter} from '#mark';
 import {
-    getNext,
+    callWithNext,
     isNext,
     isNextParent,
 } from '#is';
@@ -17,9 +17,9 @@ const {
 const hasFnBody = ({node}) => node.body.body.length;
 
 const isIndentAfter = createTypeChecker([
-    ['+', getNext(isFunctionDeclaration)],
+    ['+', callWithNext(isFunctionDeclaration)],
     ['+', isNext],
-    ['-: -> !', getNext(isExpressionStatement)],
+    ['-: -> !', callWithNext(isExpressionStatement)],
 ]);
 
 const isNotInsideExportDefaultWithBody = createTypeChecker([

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

@@ -39,10 +39,7 @@ const {
 
 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'));
 

package/lib/tokenize/is.js

@@ -30,7 +30,7 @@ export const isInsideTSModuleBlock = ({parentPath}) => isTSModuleBlock(parentPat
 
 export const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
 export const isInsideReturn = ({parentPath}) => parentPath.isReturnStatement();
-export const getNext = (fn) => (path) => fn(path.getNextSibling());
+export const callWithNext = (fn) => (path) => fn(path.getNextSibling());
 
 export const isNext = (path) => {
     const next = path.getNextSibling();

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

@@ -8,7 +8,7 @@ import {
     hasTrailingComment,
     isCoupleLines,
     isInsideReturn,
-    getNext,
+    callWithNext,
     hasLeadingComment,
 } from '#is';
 import {
@@ -27,7 +27,7 @@ const isCallInsideExpression = createTypeChecker([
 
 const isNextToAssignmentCall = createTypeChecker([
     '-: node.expression -> AssignmentExpression',
-    ['+', getNext(isCallInsideExpression)],
+    ['+', callWithNext(isCallInsideExpression)],
 ]);
 
 const isBreaklineAfter = createTypeChecker([
@@ -44,7 +44,7 @@ const isNextStatementWithBlockComment = createTypeChecker([
 
 const isBreakline = createTypeChecker([
     isNewlineBetweenSiblings,
-    getNext(isIfStatement),
+    callWithNext(isIfStatement),
 ]);
 
 const isIndent = createTypeChecker([
@@ -55,7 +55,7 @@ const isIndent = createTypeChecker([
 
 export const isIndentAfter = createTypeChecker([
     '-: node.expression -> !AssignmentExpression',
-    ['+', getNext(hasLeadingComment)],
+    ['+', callWithNext(hasLeadingComment)],
 ]);
 
 export const ExpressionStatement = {

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

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

package/package.json

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