@putout/printer 18.1.1 → 18.1.3

package/ChangeLog

@@ -1,3 +1,16 @@
+2026.03.06, v18.1.3
+
+fix:
+- 033b2a6 @putout/printer: ArrayExpression: maxElementLengthInOneLine
+
+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:

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();
@@ -151,10 +151,13 @@ const isMoreThenMaxLiteralLength = (path, {maxElementLengthInOneLine}) => {
     return first.value.length > maxElementLengthInOneLine;
 };
 
-const isMoreThenMaxIdentifierLength = (path) => {
+const isMoreThenMaxIdentifierLength = (path, {maxElementLengthInOneLine}) => {
     const [first] = path.node.elements;
     
-    return isIdentifier(first);
+    if (!isIdentifier(first))
+        return false;
+    
+    return first.name.length > maxElementLengthInOneLine;
 };
 
 const isMoreThenMaxElementLengthInOneLine = createTypeChecker([

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

@@ -16,6 +16,7 @@ const isExcludedFromChain = satisfy([
     isUnaryExpression,
     isIfStatement,
 ]);
+
 const hasComment = ({type}) => type === 'CommentLine';
 
 const isInsideMemberCall = (path) => {

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

@@ -38,10 +38,12 @@ const {
 } = types;
 
 const isLogicalArgument = (path) => isLogicalExpression(path.node.argument);
+
 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

@@ -90,4 +90,3 @@ export const ExpressionStatement = {
         maybe.markAfter(store(), path);
     },
 };
-

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.1",
+  "version": "18.1.3",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",