@putout/printer 18.7.9 → 18.8.1

package/ChangeLog

@@ -1,3 +1,19 @@
+2026.03.19, v18.8.1
+
+feature:
+- cbc16cf6 @putout/printer: ObjectPattern: isBreaklineBeforeProperty
+- a78cf04e @putout/printer: ObjectPattern: isCommaAfterProperty
+- c5b21af0 @putout/printer: ObjectPattern: simplify
+- 394ff5e4 @putout/printer: ObjectPattern: calculateLongAssignPattern: simplify
+- 42c8dfd4 @putout/printer: ObjectPattern: isIndentBeforeProperty
+
+2026.03.18, v18.8.0
+
+feature:
+- cc719056 @putout/printer: ArrayExpression: newline
+- 53cdda91 @putout/printer: maxElementsInOneLine: 3
+- e5d67901 @putout/printer: ObjectPattern: isPrevAssignObject: simplify
+
 2026.03.18, v18.7.9
 
 feature:

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

@@ -1,7 +1,6 @@
 import {
     isCoupleLines,
     isIdentifierAndIdentifier,
-    isStringAndIdentifier,
 } from '#is';
 import {createTypeChecker} from '#type-checker';
 import {isInsideOneElementArray} from './before-if.js';
@@ -10,6 +9,5 @@ export const afterIf = createTypeChecker([
     ['-: parentPath -> !ArrayExpression'],
     ['-: parentPath ->', isCoupleLines],
     ['+', isIdentifierAndIdentifier],
-    ['-: -> !', isStringAndIdentifier],
     ['+', isInsideOneElementArray],
 ]);

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

@@ -3,7 +3,6 @@ import {
     isCoupleLines,
     isIdentifierAndIdentifier,
     isInsideArray,
-    isStringAndIdentifier,
 } from '#is';
 
 export const isInsideOneElementArray = ({parentPath}) => {
@@ -11,14 +10,9 @@ export const isInsideOneElementArray = ({parentPath}) => {
     return elements.length === 1;
 };
 
-const isStringAndIdentifierInsideOneElementArray = createTypeChecker([
-    ['-: -> !', isStringAndIdentifier],
-    ['+', isInsideOneElementArray],
-]);
-
 export const beforeIf = createTypeChecker([
     ['-: -> !', isInsideArray],
     ['-: parentPath ->', isCoupleLines],
     ['+', isIdentifierAndIdentifier],
-    ['+', isStringAndIdentifierInsideOneElementArray],
+    ['+', isInsideOneElementArray],
 ]);

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

@@ -109,7 +109,6 @@ const isLastElementObjectExpression = ({node}) => isObjectExpression(node.elemen
 export const isSecondIndent = createTypeChecker([
     ['-: -> !', isMultilineOption],
     ['+', isNeedsToHideIndentOption],
-    ['-: ->', isArrayInsideArray],
     ['+: -> !', isLastElementObjectExpression],
 ]);
 

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

@@ -15,6 +15,20 @@ import {
 import {isIncreaseIndent} from './indent.js';
 import {isMultilineOption} from './is.js';
 
+const {
+    isObjectExpression,
+    isObjectProperty,
+    isCallExpression,
+    isAwaitExpression,
+    isBooleanLiteral,
+    isNullLiteral,
+    isStringLiteral,
+    isSpreadElement,
+    isIdentifier,
+    isNumericLiteral,
+    isArrayExpression,
+} = types;
+
 const isParentProperty = (path) => path.find(isObjectProperty);
 
 const isNumbersArray = createTypeChecker([
@@ -70,19 +84,6 @@ const isShortTwoSimplesInsideCall = (path, {maxElementsInOneLine}) => {
     return length < maxElementsInOneLine;
 };
 
-const {
-    isObjectExpression,
-    isObjectProperty,
-    isCallExpression,
-    isAwaitExpression,
-    isBooleanLiteral,
-    isNullLiteral,
-    isStringLiteral,
-    isSpreadElement,
-    isIdentifier,
-    isNumericLiteral,
-} = types;
-
 const {round} = Math;
 
 const isOneSpread = (path) => {
@@ -138,12 +139,13 @@ const isSiblingIsArray = (path) => {
 
 const isMoreThenMaxLiteralLength = (path, {maxElementLengthInOneLine}) => {
     const {elements} = path.node;
-    const [first] = elements;
     
-    if (!isStringLiteral(first))
-        return false;
+    for (const element of elements.filter(isStringLiteral)) {
+        if (element.value.length >= maxElementLengthInOneLine)
+            return true;
+    }
     
-    return first.value.length > maxElementLengthInOneLine;
+    return false;
 };
 
 const isMoreThenMaxIdentifierLength = (path, {maxElementLengthInOneLine}) => {
@@ -197,8 +199,49 @@ const isBodyWithOneElement = createTypeChecker([
     ['+', isBody],
 ]);
 
+const isLengthLessTheMax = (length, {maxElementsInOneLine}) => length <= maxElementsInOneLine;
+
+const isAllStrings = (path) => {
+    const {elements} = path.node;
+    const {length} = elements.filter(isStringLiteral);
+    
+    return elements.length === length;
+};
+
+const isTupleInsideArray = createTypeChecker([
+    ['-: parentPath -> !ArrayExpression'],
+    ['-: -> !', isAllStrings],
+    ['-', isMoreThenMaxLiteralLength],
+    ['+: node.elements.length', isLengthLessTheMax],
+]);
+
+const isMixedTuples = (path, {maxElementLengthInOneLine}) => {
+    const elements = path.get('elements');
+    
+    const arrayElements = elements.filter(isArrayExpression);
+    const {length} = arrayElements;
+    
+    if (!length)
+        return false;
+    
+    if (isObjectProperty(path.parentPath))
+        return false;
+    
+    for (const arrayElement of arrayElements) {
+        if (isMoreThenMaxLiteralLength(arrayElement, {maxElementLengthInOneLine}))
+            return false;
+        
+        if (isAllStrings(arrayElement))
+            return true;
+    }
+    
+    return false;
+};
+
 export const isMultiLine = createTypeChecker([
     ['-: node.elements.length -> -'],
+    ['-', isTupleInsideArray],
+    ['+', isMixedTuples],
     ['+', isBodyWithOneElement],
     ['+', isMoreThenMaxElementLengthInOneLine],
     ['+', isElementsMoreThenMaxWithFirstString],
@@ -207,7 +250,6 @@ export const isMultiLine = createTypeChecker([
     ['-', isOneSimple],
     ['-', isOneSpread],
     ['-', isIdentifierAndIdentifier],
-    ['-', isCallInsideArrow],
     ['-', isIncreaseIndent],
     ['-', isInsideLoop],
     ['-', isBooleanAndSimple],
@@ -268,32 +310,20 @@ function isInsideLoop(path) {
     return path.parentPath.isForOfStatement();
 }
 
-function tooLong(path) {
+function tooLong(path, {maxElementLengthInOneLine}) {
     const elements = path.get('elements');
     
     if (elements.length < 2)
         return false;
     
     for (const el of path.get('elements')) {
-        if (el.isStringLiteral() && el.node.value.length > 4)
+        if (el.isStringLiteral() && el.node.value.length > maxElementLengthInOneLine)
             return true;
     }
     
     return false;
 }
 
-function isCallInsideArrow(path) {
-    const {parentPath} = path;
-    
-    if (!parentPath.isCallExpression())
-        return false;
-    
-    if (!parentPath.parentPath.isFunction())
-        return false;
-    
-    return path.node.elements.length < 4;
-}
-
 function isNumbers(elements) {
     for (const element of elements) {
         if (isNumericLiteral(element))

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

@@ -1,5 +1,9 @@
 import {types} from '@putout/babel';
 import {createTypeChecker} from '#type-checker';
+import {
+    isFirstArgOfCall,
+    isLastArgInCall,
+} from '#is';
 import {chain} from '../chain.js';
 import {checkCallsCount} from './check-calls-count.js';
 
@@ -18,26 +22,6 @@ const {
     isCallExpression,
 } = types;
 
-const isPathFirstArg = ({node, parentPath}) => {
-    const [first] = parentPath.node.arguments;
-    return node === first;
-};
-
-function isPathLastArg({node, parentPath}) {
-    const last = parentPath.node.arguments.at(-1);
-    return node === last;
-}
-
-const isFirstArgOfCall = createTypeChecker([
-    ['-: parentPath -> !CallExpression'],
-    ['+', isPathFirstArg],
-]);
-
-const isLastArgInCall = createTypeChecker([
-    ['-: parentPath -> !CallExpression'],
-    ['+', isPathLastArg],
-]);
-
 const callWithRoot = (fn) => (a, {root}) => fn(root);
 
 const isExcludedFromChain = createTypeChecker([

package/lib/tokenize/expressions/object-pattern/calculate-long-assign-pattern.js

@@ -1,41 +1,20 @@
-import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
+import {isNextAssignObject} from './is.js';
 
-const {
-    isAssignmentPattern,
-    isArrayExpression,
-    isObjectExpression,
-    isIdentifier,
-} = types;
-
-export const calculateAssigns = (property, semantics) => {
-    const currentAssign = isLongAssignPattern(property, semantics);
-    
-    const {right} = property.node.value;
-    const isArrayOrObjectRight = isArrayExpression(right) || isComplexObject(right);
-    const complexAssign = currentAssign && isArrayOrObjectRight;
-    
-    return {
-        complexAssign,
-    };
+const isMoreThenMaxPropertiesLengthInOneLineOption = (a, {semantics}) => {
+    const {maxPropertiesLengthInOneLine} = semantics;
+    return a > maxPropertiesLengthInOneLine;
 };
 
-export function isLongAssignPattern(path, semantics) {
-    const {key, value} = path.node;
-    
-    if (!isAssignmentPattern(value))
-        return false;
-    
-    if (!isIdentifier(key))
-        return true;
-    
-    const {maxPropertiesLengthInOneLine} = semantics;
-    
-    return key.name.length > maxPropertiesLengthInOneLine;
-}
+const isCoupleOption = (a, {couple}) => couple;
+
+const isNextAssignAndCurrentNotAssign = createTypeChecker([
+    ['-: ->', isCoupleOption],
+    ['+: node.value -> AssignmentPattern'],
+    ['+: -> !', isNextAssignObject],
+]);
 
-function isComplexObject(node) {
-    if (!isObjectExpression(node))
-        return false;
-    
-    return node.properties.length;
-}
+export const isBreaklineBeforeProperty = createTypeChecker([
+    ['-: ->', isNextAssignAndCurrentNotAssign],
+    ['+: node.key.name.length -> !', isMoreThenMaxPropertiesLengthInOneLineOption],
+]);

package/lib/tokenize/expressions/object-pattern/comma.js

@@ -1,5 +1,11 @@
 import {types} from '@putout/babel';
 import {createTypeChecker} from '#type-checker';
+import {callWithNext} from '#is';
+import {
+    hasOptionIs,
+    isNextAssignObject,
+    isPrevAssignObject,
+} from './is.js';
 
 const {
     isForOfStatement,
@@ -18,11 +24,24 @@ export function isPrevAssign(path) {
     return isAssignmentPattern(prev.node.value);
 }
 
+const hasNode = (path) => path.node;
+
 export const isCommaAfterProperty = createTypeChecker([
     ['+', isCoupleOption],
+    ['+', hasOptionIs],
+    ['+', isNextAssignObject],
+    ['+', isPrevAssignObject],
+    ['+', callWithNext(hasNode)],
     ['-: key -> -'],
     ['-', isPrevAssign],
     ['-: parentPath', isInsideForOf],
     ['+: node.value.right -> ObjectExpression'],
 ]);
 
+export const isNewlineAfterComma = createTypeChecker([
+    ['+', isCoupleOption],
+    ['-: key -> -'],
+    ['-', isPrevAssign],
+    ['-: parentPath', isInsideForOf],
+    ['+: node.value.right -> ObjectExpression'],
+]);

package/lib/tokenize/expressions/object-pattern/indent.js

@@ -0,0 +1,12 @@
+import {createTypeChecker} from '#type-checker';
+import {
+    hasOptionIs,
+    isInsideFn,
+    isPrevAssignObject,
+} from './is.js';
+
+export const isIndentBeforeProperty = createTypeChecker([
+    ['-', isInsideFn],
+    ['+', isPrevAssignObject],
+    ['+', hasOptionIs],
+]);

package/lib/tokenize/expressions/object-pattern/is.js

@@ -1,15 +1,21 @@
 import {types} from '@putout/babel';
-import {isCoupleLines, exists} from '#is';
+import {createTypeChecker} from '#type-checker';
+import {
+    isCoupleLines,
+    exists,
+    callWithPrev,
+    callWithNext,
+} from '#is';
 import {hasAssign} from './has.js';
 
 const {
-    isObjectExpression,
-    isAssignmentPattern,
     isFunction,
     isVariableDeclarator,
     isObjectProperty,
 } = types;
 
+export const hasOptionIs = (a, {is}) => is;
+
 export const isInsideFn = (path) => {
     if (isFunction(path.parentPath))
         return true;
@@ -37,27 +43,13 @@ export const isCoupleProperties = ({path, valuePath, property}) => {
     return !isObjectProperty(parentPath);
 };
 
-export function isPrevAssignObject(path) {
-    const prev = path.getPrevSibling();
-    
-    if (!isAssignmentPattern(prev.node.value))
-        return false;
-    
-    const {right} = prev.node.value;
-    
-    return isObjectExpression(right);
-}
+export const isPrevAssignObject = callWithPrev(createTypeChecker([
+    '-: node.value -> !AssignmentPattern',
+    '+: node.value.right -> ObjectExpression',
+]));
 
-export function isNextAssignObject(path) {
-    const next = path.getNextSibling();
-    
-    if (!next.node)
-        return false;
-    
-    if (!isAssignmentPattern(next.node.value))
-        return false;
-    
-    const {right} = next.node.value;
-    
-    return isObjectExpression(right);
-}
+export const isNextAssignObject = callWithNext(createTypeChecker([
+    '-: node -> -',
+    '-: node.value -> !AssignmentPattern',
+    '+: node.value.right -> ObjectExpression',
+]));

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

@@ -1,17 +1,18 @@
 import {wrongShorthand} from './wrong-shorthand.js';
 import {maybeTypeAnnotation} from '../../maybe/maybe-type-annotation.js';
 import {printKey} from '../object-expression/print-key.js';
-import {
-    calculateAssigns,
-    isLongAssignPattern,
-} from './calculate-long-assign-pattern.js';
+import {isBreaklineBeforeProperty} from './calculate-long-assign-pattern.js';
 import {printLeadingComments} from './comments.js';
 import {shouldAddNewline} from './should-add-new-line.js';
 import {
     hasAssignObject,
     hasObjectPattern,
 } from './has.js';
-import {isCommaAfterProperty} from './comma.js';
+import {
+    isCommaAfterProperty,
+    isNewlineAfterComma,
+} from './comma.js';
+import {isIndentBeforeProperty} from './indent.js';
 import {
     isCoupleProperties,
     isIndent,
@@ -51,16 +52,19 @@ export const ObjectPattern = {
         maybe.print.newline(is && notInsideFn);
         
         for (const [i, property] of properties.entries()) {
+            const prevAssignObject = i && isPrevAssignObject(property);
+            
+            if (isIndentBeforeProperty(property, {is}))
+                indent();
+            
             if (property.isRestElement()) {
                 const couple = is || hasObject;
                 
-                maybe.indent(couple);
                 print(property);
                 maybe.print.newline(couple);
                 continue;
             }
             
-            const prevAssignObject = i && isPrevAssignObject(property);
             const nextAssignObject = isNextAssignObject(property);
             
             const valuePath = property.get('value');
@@ -74,11 +78,7 @@ export const ObjectPattern = {
                 valuePath,
             });
             
-            maybe.indent((prevAssignObject || is) && notInsideFn);
-            
-            maybe.print.breakline(couple && !isLongAssignPattern(property, semantics));
-            
-            if (!isAssign && nextAssignObject)
+            if (isBreaklineBeforeProperty(property, {couple, semantics}))
                 print.breakline();
             
             printLeadingComments(property, {
@@ -92,33 +92,28 @@ export const ObjectPattern = {
                 print(valuePath);
             } else if (isAssign) {
                 print(valuePath);
-                
-                if (isCommaAfterProperty(property, {couple})) {
-                    print(',');
-                    print.newline();
-                    continue;
-                }
             }
             
-            if (!isAssign && nextAssignObject && notInsideFn) {
+            if (isCommaAfterProperty(property, {is, couple}))
                 print(',');
-                print.breakline();
+            
+            if (isNewlineAfterComma(property, {couple})) {
+                print.newline();
                 continue;
             }
             
-            const {complexAssign} = calculateAssigns(property, semantics);
+            if (!isAssign && nextAssignObject && notInsideFn) {
+                print.breakline();
+                continue;
+            }
             
-            if (!complexAssign && (is || hasObject || prevAssignObject && notInsideFn)) {
-                print(',');
+            if (is || hasObject || prevAssignObject && notInsideFn) {
                 print.newline();
-                
                 continue;
             }
             
-            if (i < n && !(isAssign && couple)) {
-                print(',');
+            if (i < n && !(isAssign && couple))
                 print.space();
-            }
         }
         
         indent.dec();
@@ -128,4 +123,3 @@ export const ObjectPattern = {
         print('}');
     }),
 };
-

package/lib/tokenize/is.js

@@ -1,4 +1,5 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
 
 const {
     isStringLiteral,
@@ -202,3 +203,23 @@ export const hasTrailingComment = (path) => {
 export const hasLeadingComment = (path) => path.node?.leadingComments?.length;
 
 export const noTrailingComment = (path) => !path.node.trailingComments?.length;
+
+const isPathFirstArg = ({node, parentPath}) => {
+    const [first] = parentPath.node.arguments;
+    return node === first;
+};
+
+function isPathLastArg({node, parentPath}) {
+    const last = parentPath.node.arguments.at(-1);
+    return node === last;
+}
+
+export const isFirstArgOfCall = createTypeChecker([
+    ['-: parentPath -> !CallExpression'],
+    ['+', isPathFirstArg],
+]);
+
+export const isLastArgInCall = createTypeChecker([
+    ['-: parentPath -> !CallExpression'],
+    ['+', isPathLastArg],
+]);

package/lib/tokenize/overrides/overrides.js

@@ -32,7 +32,7 @@ const initSemantics = (format, semantics = {}) => ({
     maxPropertiesInOneLine: 2,
     maxPropertiesLengthInOneLine: 15,
     maxSpecifiersInOneLine: 2,
-    maxElementsInOneLine: 5,
+    maxElementsInOneLine: 3,
     maxElementLengthInOneLine: 15,
     maxLogicalsInOneLine: 3,
     maxVariablesInOneLine: 4,

package/package.json

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