@putout/printer 18.4.4 → 18.4.6

package/ChangeLog

@@ -1,3 +1,14 @@
+2026.03.12, v18.4.6
+
+feature:
+- 7c290de @putout/printer: BlockStatement: simplify
+- 0dc390f @putout/printer: BlockStatement: indent
+
+2026.03.12, v18.4.5
+
+feature:
+- e18f600 @putout/printer: ArrayExpression: isCommaAfterElement
+
 2026.03.11, v18.4.4
 
 feature:

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

@@ -59,12 +59,6 @@ export const ArrayExpression = {
                 multiline,
             });
             
-            const needsComma = isCommaAfterElement(path, {
-                trailingComma,
-                isLast,
-                needsIndentBeforeElement,
-            });
-            
             if (isNewlineBeforeElement(element))
                 print.newline();
             
@@ -73,8 +67,11 @@ export const ArrayExpression = {
             
             print(element);
             
-            if (needsComma)
-                print(',');
+            maybe.print(isCommaAfterElement(path, {
+                trailingComma,
+                isLast,
+                needsIndentBeforeElement,
+            }), ',');
             
             if (isNewlineAfterComma(element, {multiline})) {
                 print.newline();

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

@@ -1,27 +1,35 @@
-import {types} from '@putout/babel';
 import {markAfter} from '#mark';
+import {createTypeChecker} from '#type-checker';
+import {isInsideBlock} from '#is';
 import {parseComments} from '../../comment/comment.js';
 import {getDirectives} from './get-directives.js';
 import {isCallInsideChain} from './is-call-inside-chain.js';
 import {shouldAddNewlineAfter} from './block-statement-newline.js';
 
-const {isArrayExpression} = types;
+const isThree = (a) => a === 3;
 
-const isFirstStatement = (path) => path.node.body[0];
-const isFirstDirective = (path) => path.node.directives?.[0];
+const isInsideArrayTupleOfThree = createTypeChecker([
+    ['-: parentPath.parentPath -> !ArrayExpression'],
+    ['+: parentPath.parentPath.node.elements.length', isThree],
+]);
 
-const isInsideArrayTupleOfThree = (path) => {
-    const {parentPath} = path.parentPath;
-    
-    if (!isArrayExpression(parentPath))
-        return false;
-    
-    const {length} = parentPath.node.elements;
-    
-    return length === 3;
-};
+const hasDirectives = (a) => getDirectives(a).length;
+
+const isNewLineAfterOpenCurlyBrace = createTypeChecker([
+    ['+', hasDirectives],
+    ['+: node.body.length', Boolean],
+]);
+
+const isLinebreakAfterDirectives = createTypeChecker([
+    ['-: node.body.length -> !', Boolean],
+    ['+', hasDirectives],
+]);
 
 export const BlockStatement = {
+    beforeIf: isInsideBlock,
+    before: (path, {indent}) => {
+        indent();
+    },
     print(path, printer, semantics) {
         const {
             indent,
@@ -32,22 +40,21 @@ export const BlockStatement = {
         
         const body = path.get('body');
         const directives = getDirectives(path);
-        
-        if (path.parentPath.isBlockStatement())
-            indent();
-        
         const insideArray = isInsideArrayTupleOfThree(path);
+        
         maybe.indent.inc(!insideArray);
         write('{');
         
-        if (isFirstStatement(path) || isFirstDirective(path))
+        if (isNewLineAfterOpenCurlyBrace(path))
             write.newline();
         
         for (const directive of directives) {
             traverse(directive);
         }
         
-        maybe.write.linebreak(directives.length && body.length);
+        if (isLinebreakAfterDirectives(path))
+            write.linebreak();
+        
         const callInsideChain = isCallInsideChain(path);
         
         maybe.indent.inc(callInsideChain);

package/package.json

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