@putout/printer 18.6.5 → 18.6.6

package/ChangeLog

@@ -1,3 +1,10 @@
+2026.03.14, v18.6.6
+
+feature:
+- c4f79e0 2putout/printer: VariableDeclaration: conditions
+- 42ea012 @putout/printer: VariableDeclaration: simplify
+- 1d079db @putout/printer: VariableDeclaration: afterIf: skipAfter
+
 2026.03.14, v18.6.5
 
 feature:

package/lib/tokenize/statements/variable-declaration/after-if.js

@@ -10,6 +10,7 @@ import {
     isNext,
     callWithPrev,
 } from '#is';
+import {isNewlineAfterSemicolon} from './is.js';
 
 const {
     isIfStatement,
@@ -67,7 +68,13 @@ const isNextAssign = createTypeChecker([
     ['+', callWithNext(callWithExpression(isAssignmentExpression))],
 ]);
 
+const skipAfter = createTypeChecker([
+    ['-: parentPath -> !', isLast],
+    ['+: -> !', isInsideBlock],
+]);
+
 export const afterIf = createTypeChecker([
+    ['-', skipAfter],
     ['+', callWithNext(isIfStatement)],
     ['+', callWithNext(isFunctionDeclaration)],
     ['+', noNextParentBlock],
@@ -79,3 +86,8 @@ export const afterIf = createTypeChecker([
     ['+: parentPath -> ExportNamedDeclaration'],
     ['+: parentPath -> TSModuleBlock'],
 ]);
+
+export const isIndentAfterNewline = createTypeChecker([
+    ['-: -> !', isNewlineAfterSemicolon],
+    ['+', afterIf],
+]);

package/lib/tokenize/statements/variable-declaration/is.js

@@ -0,0 +1,32 @@
+import {createTypeChecker} from '#type-checker';
+import {
+    callWithParent,
+    isNewlineBetweenSiblings,
+    isNext,
+    noTrailingComment,
+} from '#is';
+
+export const isInsideParentLike = callWithParent(createTypeChecker([
+    'Program',
+    'BlockStatement',
+    'ExportNamedDeclaration',
+    'LabeledStatement',
+]));
+
+export const isNewlineAfterSemicolon = createTypeChecker([
+    ['+: parentPath -> SwitchCase'],
+    ['-: -> !', isInsideParentLike],
+    ['-: -> !', isNext],
+    ['+', noTrailingComment],
+    ['+', isNewlineBetweenSiblings],
+]);
+
+export const isNeedBreaklineAfterComma = (path, {maxVariablesInOneLine}) => {
+    const {length} = path.node.declarations;
+    return length > maxVariablesInOneLine;
+};
+
+export const isNeedSpaceAfterComma = (path, {maxVariablesInOneLine}) => {
+    const {length} = path.node.declarations;
+    return length <= maxVariablesInOneLine;
+};

package/lib/tokenize/statements/variable-declaration/variable-declaration.js

@@ -2,25 +2,32 @@ import {createTypeChecker} from '#type-checker';
 import {isConcatenation} from '#is-concatenation';
 import {maybeDeclare} from '#maybe-declare';
 import {parseLeadingComments} from '#comments';
+import {markAfter} from '#mark';
 import {
-    isNext,
-    isNewlineBetweenSiblings,
     exists,
-    noTrailingComment,
     isInsideIf,
     isInsideBlock,
     isInsideTSModuleBlock,
     isInsideProgram,
     isInsideSwitchCase,
     isInsideBody,
-    callWithParent,
-    isLast,
+    hasLeadingComment,
 } from '#is';
-import {afterIf} from './after-if.js';
+import {
+    afterIf,
+    isIndentAfterNewline,
+} from './after-if.js';
 import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
 import {beforeIf} from './before-if.js';
+import {
+    isInsideParentLike,
+    isNeedBreaklineAfterComma,
+    isNeedSpaceAfterComma,
+    isNewlineAfterSemicolon,
+} from './is.js';
 
 const isParentTSModuleBlock = (path) => path.parentPath.isTSModuleBlock();
+
 const isInsideBlockLike = createTypeChecker([
     isInsideProgram,
     isInsideBlock,
@@ -29,29 +36,12 @@ const isInsideBlockLike = createTypeChecker([
     isInsideBody,
 ]);
 
-const isParentSwitchCase = (path) => path.parentPath.isSwitchCase();
-
-const isInsideParentLike = callWithParent(createTypeChecker([
-    'Program',
-    'BlockStatement',
-    'ExportNamedDeclaration',
-    'LabeledStatement',
-]));
-
 const isNeedSemicolon = createTypeChecker([
-    isInsideParentLike,
-    isParentSwitchCase,
-    isParentTSModuleBlock,
-    isInsideIf,
-    isInsideBody,
-]);
-
-const isNeedNewline = createTypeChecker([
-    ['+', isParentSwitchCase],
-    ['-: -> !', isInsideParentLike],
-    ['-: -> !', isNext],
-    ['+', noTrailingComment],
-    ['+', isNewlineBetweenSiblings],
+    ['+', isInsideParentLike],
+    ['+: parentPath -> SwitchCase'],
+    ['+', isParentTSModuleBlock],
+    ['+', isInsideIf],
+    ['+', isInsideBody],
 ]);
 
 export const VariableDeclaration = {
@@ -59,12 +49,21 @@ export const VariableDeclaration = {
     before(path, {print}) {
         print.breakline();
     },
-    print: maybeDeclare((path, {maybe, store, write, traverse, print, indent}, semantics) => {
+    print: maybeDeclare((path, printer, semantics) => {
+        const {kind} = path.node;
+        const {
+            maybe,
+            write,
+            traverse,
+            indent,
+        } = printer;
+        
         const {maxVariablesInOneLine} = semantics;
         
-        maybe.indent(isInsideBlockLike(path));
+        if (isInsideBlockLike(path))
+            indent();
         
-        write(path.node.kind);
+        write(kind);
         maybeSpaceAfterKeyword(path, {
             write,
         });
@@ -88,47 +87,42 @@ export const VariableDeclaration = {
                 traverse(init);
             }
             
-            if (!isLast) {
-                const next = declarations[index + 1];
-                
-                write(',');
-                
-                if (!next.node.leadingComments) {
-                    maybe.write.breakline(n > maxVariablesInOneLine);
-                    maybe.write.space(n <= maxVariablesInOneLine);
-                    continue;
-                }
-                
-                parseLeadingComments(next, {print, maybe, indent}, semantics);
+            if (isLast)
+                continue;
+            
+            const next = declarations[index + 1];
+            
+            write(',');
+            
+            if (hasLeadingComment(next)) {
+                parseLeadingComments(next, printer, semantics);
+                continue;
             }
+            
+            if (isNeedBreaklineAfterComma(path, {maxVariablesInOneLine})) {
+                write.breakline();
+                continue;
+            }
+            
+            if (isNeedSpaceAfterComma(path, {maxVariablesInOneLine}))
+                write.space();
         }
         
         maybe.indent.dec(n);
-        maybe.write(isNeedSemicolon(path), ';');
         
-        let wasNewline = false;
+        if (isNeedSemicolon(path))
+            write(';');
         
-        if (isNeedNewline(path)) {
+        if (isNewlineAfterSemicolon(path))
             write.newline();
-            wasNewline = true;
-        }
         
-        store(wasNewline);
+        if (isIndentAfterNewline(path)) {
+            indent();
+            markAfter(path);
+        }
     }),
     afterIf,
-    after(path, {maybe, store, print}) {
-        const wasNewline = store();
-        
-        if (skipAfter(path))
-            return;
-        
-        maybe.indent(wasNewline);
+    after(path, {print}) {
         print.newline();
-        maybe.markAfter(wasNewline, path);
     },
 };
-
-const skipAfter = createTypeChecker([
-    ['-: parentPath -> !', isLast],
-    ['+: -> !', isInsideBlock],
-]);

package/package.json

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