@putout/printer 18.8.0 → 18.8.2

package/ChangeLog

@@ -1,3 +1,18 @@
+2026.03.19, v18.8.2
+
+feature:
+- 62e8f395 @putout/printer: ObjectPattern: isIndentAfterNewline
+- 03b337f7 @putout/printer: ObjectPattern: isNewlineAfterComma: simplify
+
+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:

package/lib/tokenize/comments/comments-printer/comments-printer.js

@@ -59,7 +59,8 @@ export const printLeadingComments = (path, printer, semantics, {currentTraverse}
 export const printTrailingComments = (path, printer, semantics, {currentTraverse}) => {
     const {print} = printer;
     const {
-        trailingComments = []} = path.node;
+        trailingComments = [],
+    } = path.node;
     
     const {
         printTrailingCommentLine,

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,10 +24,25 @@ 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([
+    ['+', hasOptionIs],
+    ['+', isPrevAssignObject],
+    ['+', isCoupleOption],
+    ['+', isNextAssignObject],
+    ['-: key -> -'],
+    ['+: node.value.right -> ObjectExpression'],
+]);

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

@@ -0,0 +1,18 @@
+import {createTypeChecker} from '#type-checker';
+import {
+    hasOptionIs,
+    isInsideFn,
+    isNextAssignObject,
+    isPrevAssignObject,
+} from './is.js';
+
+export const isIndentBeforeProperty = createTypeChecker([
+    ['-', isInsideFn],
+    ['+', isPrevAssignObject],
+    ['+', hasOptionIs],
+]);
+
+export const isIndentAfterNewline = createTypeChecker([
+    ['-: node.value -> AssignmentPattern'],
+    ['+', isNextAssignObject],
+]);

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

@@ -14,6 +14,8 @@ const {
     isObjectProperty,
 } = types;
 
+export const hasOptionIs = (a, {is}) => is;
+
 export const isInsideFn = (path) => {
     if (isFunction(path.parentPath))
         return true;
@@ -46,4 +48,8 @@ export const isPrevAssignObject = callWithPrev(createTypeChecker([
     '+: node.value.right -> ObjectExpression',
 ]));
 
-export const isNextAssignObject = callWithNext(createTypeChecker(['-: node -> -', '-: node.value -> !AssignmentPattern', '+: node.value.right -> ObjectExpression']));
+export const isNextAssignObject = callWithNext(createTypeChecker([
+    '-: node -> -',
+    '-: node.value -> !AssignmentPattern',
+    '+: node.value.right -> ObjectExpression',
+]));

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

@@ -1,23 +1,25 @@
 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,
+    isIndentAfterNewline,
+} from './indent.js';
 import {
     isCoupleProperties,
     isIndent,
     isInsideFn,
-    isNextAssignObject,
-    isPrevAssignObject,
 } from './is.js';
 
 export const ObjectPattern = {
@@ -51,18 +53,17 @@ export const ObjectPattern = {
         maybe.print.newline(is && notInsideFn);
         
         for (const [i, property] of properties.entries()) {
+            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');
             const keyPath = property.get('key');
             const isAssign = valuePath.isAssignmentPattern();
@@ -74,11 +75,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 +89,22 @@ 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();
-                continue;
-            }
-            
-            const {complexAssign} = calculateAssigns(property, semantics);
             
-            if (!complexAssign && (is || hasObject || prevAssignObject && notInsideFn)) {
-                print(',');
+            if (isNewlineAfterComma(property, {is, couple})) {
                 print.newline();
                 
+                if (isIndentAfterNewline(property))
+                    indent();
+                
                 continue;
             }
             
-            if (i < n && !(isAssign && couple)) {
-                print(',');
+            if (i < n)
                 print.space();
-            }
         }
         
         indent.dec();

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

@@ -42,7 +42,12 @@ export const report = (coverage) => {
 };
 
 const setLine = (name, index) => {
-    const [at, uri, line, column] = name.split(':');
+    const [
+        at,
+        uri,
+        line,
+        column,
+    ] = name.split(':');
     const newLine = Number(line) + index + 1;
     
     return [

package/package.json

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