@putout/printer 18.0.6 → 18.0.8

package/ChangeLog

@@ -1,3 +1,14 @@
+2026.03.05, v18.0.8
+
+feature:
+- 08b7207 @putout/printer: VariableDeclaration: inside ForStatement
+- dda61cc @putout/printer: type-check-coverage: check for only
+
+2026.03.05, v18.0.7
+
+feature:
+- dd7f874 @putout/printer: VariableDeclaration: inside ForOfStatement: indent
+
 2026.03.05, v18.0.6
 
 feature:

package/lib/tokenize/expressions/class/class.js

@@ -90,13 +90,15 @@ export const ClassDeclaration = {
         classVisitor(path, printer, semantics);
     }),
     afterIf(path) {
+        const {parentPath} = path;
+        
         if (isFunctionLike(path))
             return true;
         
         if (isNext(path))
             return true;
         
-        return isInsideTSModuleBlock(path);
+        return isInsideTSModuleBlock(parentPath);
     },
     after(path, {write}) {
         write.newline();

package/lib/tokenize/expressions/function/function-declaration.js

@@ -1,11 +1,7 @@
 import {types} from '@putout/babel';
 import {printParams} from '#print-params';
 import {markAfter} from '#mark';
-import {
-    isInsideTSModuleBlock,
-    isNext,
-    isNextParent,
-} from '#is';
+import {isNext, isNextParent} from '#is';
 import {createTypeChecker} from '#type-checker';
 
 const {
@@ -22,11 +18,7 @@ const isInsideExportDefaultWithBody = createTypeChecker([
     ['+', hasFnBody],
 ]);
 
-const isInsideBlockLike = createTypeChecker([
-    ['+', isInsideTSModuleBlock],
-    '-: parentPath -> !BlockStatement',
-    ['+: -> !', hasFnBody],
-]);
+const isInsideBlockLike = createTypeChecker(['+: parentPath.parentPath -> TSModuleBlock', '-: parentPath -> !BlockStatement', ['+: -> !', hasFnBody]]);
 
 const not = (fn) => (...a) => !fn(...a);
 const notInsideExportDefaultWithBody = not(isInsideExportDefaultWithBody);

package/lib/tokenize/is.js

@@ -1,5 +1,4 @@
 import {types} from '@putout/babel';
-import {createTypeChecker} from '#type-checker';
 
 const {
     isStringLiteral,
@@ -16,21 +15,14 @@ const {
     isProgram,
     isBlockStatement,
     isTSModuleBlock,
+    isSwitchCase,
 } = types;
 
 export const isInsideProgram = (path) => isProgram(path.parentPath);
 export const isInsideBlock = (path) => isBlockStatement(path.parentPath);
+export const isInsideSwitchCase = (path) => isSwitchCase(path.parentPath);
 
-export const isInsideBlockLike = createTypeChecker('path.parentPath', [
-    'Program',
-    'BlockStatement',
-    'TSModuleBlock',
-    'SwitchCase',
-]);
-
-export const isInsideTSModuleBlock = ({parentPath}) => {
-    return isTSModuleBlock(parentPath?.parentPath);
-};
+export const isInsideTSModuleBlock = ({parentPath}) => isTSModuleBlock(parentPath);
 
 export const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
 

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

@@ -7,25 +7,37 @@ import {
     isNewlineBetweenSiblings,
     exists,
     noTrailingComment,
-    isInsideBlockLike,
     isInsideIf,
     isInsideBlock,
     isInsideExport,
+    isInsideTSModuleBlock,
+    isInsideProgram,
+    isInsideSwitchCase,
 } from '#is';
 import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
 import {isConcatenation} from '../../expressions/binary-expression/concatenate.js';
 import {parseLeadingComments} from '../../comment/comment.js';
 import {maybeDeclare} from '../../maybe/maybe-declare.js';
 
-const isLast = (path) => path.parentPath?.isProgram() && !isNext(path);
-
 const {isExportDeclaration} = types;
 
+const isInsideBody = (path) => path.node === path.parentPath.node.body;
+
+const isInsideBlockLike = createTypeChecker([
+    isInsideProgram,
+    isInsideBlock,
+    isInsideTSModuleBlock,
+    isInsideSwitchCase,
+    isInsideBody,
+]);
+
+const isLast = (path) => path.parentPath?.isProgram() && !isNext(path);
+
 const isParentTSModuleBlock = (path) => path.parentPath.isTSModuleBlock();
 const isParentSwitchCase = (path) => path.parentPath.isSwitchCase();
 const isFirstInSwitch = (path) => path.parentPath.get('consequent.0') === path;
 
-const isIsideParentLike = createTypeChecker('path.parentPath', [
+const isInsideParentLike = createTypeChecker('path.parentPath', [
     'Program',
     'BlockStatement',
     'ExportNamedDeclaration',
@@ -33,14 +45,15 @@ const isIsideParentLike = createTypeChecker('path.parentPath', [
 ]);
 
 const isNeedSemicolon = createTypeChecker([
-    isIsideParentLike,
+    isInsideParentLike,
     isParentSwitchCase,
     isParentTSModuleBlock,
     isInsideIf,
+    isInsideBody,
 ]);
 
 const isNeedNewline = createTypeChecker([
-    ['-: -> !', isIsideParentLike],
+    ['-: -> !', isInsideParentLike],
     ['-: -> !', isNext],
     ['+', noTrailingComment],
     ['+', isNewlineBetweenSiblings],

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

@@ -1,4 +1,4 @@
-import {env} from 'node:process';
+import {env as _env} from 'node:process';
 
 const STACK_INDEX = 3;
 
@@ -6,7 +6,12 @@ const parseCallLocation = ({stack}) => stack.split('\n')[STACK_INDEX];
 
 const Coverage = new Map();
 
-export const instrument = (typeNames, fn) => {
+export const instrument = (typeNames, fn, overrides = {}) => {
+    const {
+        env = _env,
+        coverage = Coverage,
+    } = overrides;
+    
     const {length} = typeNames;
     const error = Error();
     const location = parseCallLocation(error);
@@ -14,7 +19,7 @@ export const instrument = (typeNames, fn) => {
     const covered = new Set();
     
     if (on && !location.includes('type-checker.spec.js'))
-        Coverage.set(location, {
+        coverage.set(location, {
             length,
             covered,
             typeNames,

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

@@ -49,4 +49,3 @@ export function parseTypeNames(typeNames) {
     
     return tuples;
 }
-

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

@@ -3,6 +3,11 @@ import {instrument} from '#type-checker/instrument';
 import {parseOperation, parseTypeNames} from './parsers.js';
 import {equal, maybeCall} from './comparators.js';
 
+const SKIP = [
+    Infinity,
+    false,
+];
+
 export const createTypeChecker = (deepness, typeNames) => {
     if (!typeNames) {
         typeNames = deepness;
@@ -30,6 +35,9 @@ export const createTypeChecker = (deepness, typeNames) => {
             if (selector)
                 currentPath = jessy(selector, path);
             
+            if (!currentPath)
+                return SKIP;
+            
             const {type} = currentPath;
             
             if (equal(not, type, typeName))
@@ -39,9 +47,6 @@ export const createTypeChecker = (deepness, typeNames) => {
                 return [index, result];
         }
         
-        return [
-            Infinity,
-            false,
-        ];
+        return SKIP;
     });
 };

package/package.json

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