@putout/printer 18.6.5 → 18.7.0

package/ChangeLog

@@ -1,3 +1,16 @@
+2026.03.14, v18.7.0
+
+feature:
+- b18dfef @putout/printer: SwitchStatement: space: improve support
+- e5d54cd @putout/printer: SwitchStatement: simplify
+
+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/switch-statement/switch-statement.js

@@ -1,18 +1,21 @@
+import {types} from '@putout/babel';
 import {
     isNext,
     exists,
     isLast,
 } from '#is';
 import {parseLeadingComments} from '#comments';
+import {createTypeChecker} from '#type-checker';
 import {maybeSpaceAfterKeyword} from '../return-statement/maybe-space-after-keyword.js';
 
+const {isBlockStatement} = types;
+
 export const SwitchStatement = {
     print(path, printer, semantics) {
         const {
             print,
             maybe,
             indent,
-            write,
             traverse,
         } = printer;
         
@@ -20,7 +23,9 @@ export const SwitchStatement = {
         print('switch');
         print('(');
         print('__discriminant');
-        print(') {');
+        print(')');
+        print.space();
+        print('{');
         print.newline();
         
         const cases = path.get('cases');
@@ -28,45 +33,46 @@ export const SwitchStatement = {
         
         for (const [index, switchCase] of cases.entries()) {
             const test = switchCase.get('test');
+            const isLast = index === n;
             
             indent();
             
             parseLeadingComments(switchCase, printer, semantics);
             
             if (exists(test)) {
-                write('case');
+                print('case');
                 maybeSpaceAfterKeyword(test, printer, semantics);
                 traverse(test);
             } else {
-                write('default');
+                print('default');
             }
             
             print(':');
             
+            if (isNewlineAfterColon(switchCase))
+                print.newline();
+            
             const consequents = switchCase.get('consequent');
-            const isBlock = switchCase.get('consequent.0')?.isBlockStatement();
+            const [first] = consequents;
+            const isBlock = isBlockStatement(first);
             
             maybe.indent.inc(!isBlock);
-            maybe.print.newline(!isBlock && consequents.length);
             
             for (const consequent of consequents) {
-                if (!consequent.isBlockStatement()) {
-                    print(consequent);
-                    continue;
-                }
+                if (isBlockStatement(consequent))
+                    print.space();
                 
-                print.space();
                 print(consequent);
             }
             
             maybe.indent.dec(!isBlock);
-            maybe.write.linebreak(index < n);
+            maybe.print.linebreak(!isLast);
         }
         
         print.indent();
         print('}');
         
-        if (!isNext(path) && !isLast(path))
+        if (isNewlineAfterClosingCurlyBrace(path))
             print.newline();
     },
     afterSatisfy: () => [
@@ -77,3 +83,13 @@ export const SwitchStatement = {
         print.newline();
     },
 };
+
+const isNewlineAfterClosingCurlyBrace = createTypeChecker([
+    ['-', isNext],
+    ['+: -> !', isLast],
+]);
+
+const isNewlineAfterColon = createTypeChecker([
+    ['-: node.consequent.length -> !', Boolean],
+    ['+: node.consequent.0 -> !BlockStatement'],
+]);

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