@putout/printer 18.0.5 → 18.0.7

package/ChangeLog

@@ -1,3 +1,13 @@
+2026.03.05, v18.0.7
+
+feature:
+- dd7f874 @putout/printer: VariableDeclaration: inside ForOfStatement: indent
+
+2026.03.05, v18.0.6
+
+feature:
+- 2b1dbb4 @putout/printer: check-types: instrument
+
 2026.03.04, v18.0.5
 
 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,47 @@ 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';
 
+export const isInsideForOfBody = (path) => {
+    const {parentPath} = path;
+    
+    if (!isForOfStatement(parentPath))
+        return false;
+    
+    return path.parentPath.node.body === path.node;
+};
+
+const isInsideBlockLike = createTypeChecker([
+    isInsideProgram,
+    isInsideBlock,
+    isInsideTSModuleBlock,
+    isInsideSwitchCase,
+    isInsideForOfBody,
+]);
+
 const isLast = (path) => path.parentPath?.isProgram() && !isNext(path);
 
-const {isExportDeclaration} = types;
+const {
+    isExportDeclaration,
+    isForOfStatement,
+} = types;
 
 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 +55,15 @@ const isIsideParentLike = createTypeChecker('path.parentPath', [
 ]);
 
 const isNeedSemicolon = createTypeChecker([
-    isIsideParentLike,
+    isInsideParentLike,
     isParentSwitchCase,
     isParentTSModuleBlock,
     isInsideIf,
+    isInsideForOfBody,
 ]);
 
 const isNeedNewline = createTypeChecker([
-    ['-: -> !', isIsideParentLike],
+    ['-: -> !', isInsideParentLike],
     ['-: -> !', isNext],
     ['+', noTrailingComment],
     ['+', isNewlineBetweenSiblings],

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

@@ -0,0 +1,33 @@
+import {env} from 'node:process';
+
+const STACK_INDEX = 3;
+
+const parseCallLocation = ({stack}) => stack.split('\n')[STACK_INDEX];
+
+const Coverage = new Map();
+
+export const instrument = (typeNames, fn) => {
+    const {length} = typeNames;
+    const error = Error();
+    const location = parseCallLocation(error);
+    const on = env.TYPE_CHECK;
+    const covered = new Set();
+    
+    if (on && !location.includes('type-checker.spec.js'))
+        Coverage.set(location, {
+            length,
+            covered,
+            typeNames,
+        });
+    
+    return (path, options) => {
+        const [index, result] = fn(path, options);
+        
+        if (on && index !== Infinity)
+            covered.add(index);
+        
+        return result;
+    };
+};
+
+export const getCoverage = () => Coverage;

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

@@ -1,6 +1,6 @@
-import {isArray} from '@putout/compare/lib/is.js';
 import {createTuple} from './create-tuple.js';
 
+const {isArray} = Array;
 const isString = (a) => typeof a === 'string';
 
 export const parseOperation = (operation) => {

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

@@ -1,7 +1,13 @@
 import {jessy} from 'jessy';
+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;
@@ -10,31 +16,37 @@ export const createTypeChecker = (deepness, typeNames) => {
     
     const tuples = parseTypeNames(typeNames);
     
-    return (path, options) => {
+    return instrument(typeNames, (path, options) => {
         let i = deepness.split('.').length;
         
         while (--i)
             path = path?.parentPath;
         
         if (!path)
-            return false;
+            return [
+                Infinity,
+                false,
+            ];
         
-        for (const [operation, typeName] of tuples) {
+        for (const [index, [operation, typeName]] of tuples.entries()) {
             const [result, selector, not] = parseOperation(operation);
             let currentPath = path;
             
             if (selector)
                 currentPath = jessy(selector, path);
             
+            if (!currentPath)
+                return SKIP;
+            
             const {type} = currentPath;
             
             if (equal(not, type, typeName))
-                return result;
+                return [index, result];
             
             if (maybeCall(typeName, not, currentPath, options))
-                return result;
+                return [index, result];
         }
         
-        return false;
-    };
+        return SKIP;
+    });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "18.0.5",
+  "version": "18.0.7",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -19,16 +19,16 @@
   "scripts": {
     "wisdom": "madrun wisdom",
     "test": "madrun test",
+    "test:check": "madrun test:check",
     "test:dts": "madrun test:dts",
     "watch:test": "madrun watch:test",
     "lint": "madrun lint",
     "lint:redlint": "madrun lint:redlint",
     "lint:putout": "madrun lint:putout",
-    "fresh:lint": "madrun fresh:lint",
-    "lint:fresh": "madrun lint:fresh",
+    "fresh": "madrun fresh",
     "fix:lint": "madrun fix:lint",
-    "fix:lint:putout": "madrun fix:lint:putout",
     "fix:lint:redlint": "madrun fix:lint:redlint",
+    "fix:lint:putout": "madrun fix:lint:putout",
     "coverage": "madrun coverage",
     "coverage:html": "madrun coverage:html",
     "report": "madrun report"
@@ -64,7 +64,8 @@
     "#print-params": "./lib/tokenize/expressions/function/params.js",
     "#import-attributes": "./lib/tokenize/statements/import-declaration/import-attribute.js",
     "#types": "./lib/types.js",
-    "#type-checker": "./lib/tokenize/type-checker/type-checker.js"
+    "#type-checker": "./lib/tokenize/type-checker/type-checker.js",
+    "#type-checker/instrument": "./lib/tokenize/type-checker/instrument.js"
   },
   "devDependencies": {
     "@babel/parser": "^7.28.5",
@@ -76,6 +77,7 @@
     "@putout/plugin-react-hook-form": "^6.0.0",
     "@putout/plugin-react-hooks": "^9.0.0",
     "acorn": "^8.8.2",
+    "chalk": "^5.6.2",
     "check-dts": "^0.9.0",
     "escover": "^6.0.0",
     "eslint": "^10.0.0",