@putout/printer 18.1.7 → 18.2.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2026.03.07, v18.2.0
+
+feature:
+- 87135c0 @putout/printer: type-checker: disable instrument: add support
+- 29e0a3c @putout/printer: type-checker: rm deepness
+
+2026.03.07, v18.1.8
+
+feature:
+- 35d83ea @putout/printer: type-checker: dsl inside array
+
 2026.03.07, v18.1.7
 
 feature:

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

@@ -71,8 +71,8 @@ const isSimpleBetweenObjects = createTypeChecker([
 ]);
 
 const isSpaceAfterComa = createTypeChecker([
-    callWithNext(isSimpleBetweenObjects),
-    '+: -> !ObjectExpression',
+    ['+', callWithNext(isSimpleBetweenObjects)],
+    ['+: -> !ObjectExpression'],
 ]);
 
 export const ArrayExpression = {

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

@@ -19,6 +19,6 @@ const isStringAndIdentifierInsideOneElementArray = createTypeChecker([
 export const beforeIf = createTypeChecker([
     ['-: -> !', isInsideArray],
     ['-: parentPath ->', isCoupleLines],
-    isIdentifierAndIdentifier,
-    isStringAndIdentifierInsideOneElementArray,
+    ['+', isIdentifierAndIdentifier],
+    ['+', isStringAndIdentifierInsideOneElementArray],
 ]);

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

@@ -30,7 +30,7 @@ const isStringAndString = (path) => {
 const isStringsInsideArray = createTypeChecker([
     ['-: -> !', isStringAndString],
     ['-: -> !', isInsideArray],
-    '+: parentPath.node.elements.0 -> ArrayExpression',
+    ['+: parentPath.node.elements.0 -> ArrayExpression'],
 ]);
 
 const isTwoSimplesInsideObjectProperty = (path) => {
@@ -183,13 +183,13 @@ const isElementsMoreThenThree = (path) => {
 };
 
 const isElementsMoreThenThreeWithNotFirstObject = createTypeChecker([
-    '-: node.elements.0 -> ObjectExpression',
-    isElementsMoreThenThree,
+    ['-: node.elements.0 -> ObjectExpression'],
+    ['+', isElementsMoreThenThree],
 ]);
 
 const isElementsMoreThenMaxWithFirstString = createTypeChecker([
-    '-: node.elements.0 -> !StringLiteral',
-    isElementsMoreThenMax,
+    ['-: node.elements.0 -> !StringLiteral'],
+    ['+', isElementsMoreThenMax],
 ]);
 
 const isOne = (a) => a === 1;
@@ -204,8 +204,8 @@ export const isMultiLine = createTypeChecker([
     ['+', isBodyWithOneElement],
     ['+', isMoreThenMaxElementLengthInOneLine],
     ['+', isElementsMoreThenMaxWithFirstString],
-    isElementsMoreThenThreeWithNotFirstObject,
-    isSimpleAndNotEmptyObject,
+    ['+', isElementsMoreThenThreeWithNotFirstObject],
+    ['+', isSimpleAndNotEmptyObject],
     ['-', isOneSimple],
     ['-', isOneSpread],
     ['-', isIdentifierAndIdentifier],
@@ -225,8 +225,8 @@ export const isMultiLine = createTypeChecker([
     ['-', isSimpleAndObject],
     ['-', isSiblingIsArray],
     ['-', isStringsInsideArray],
-    tooLong,
-    isCoupleLines,
+    ['+', tooLong],
+    ['+', isCoupleLines],
     ['-', isNumbersArray],
 ]);
 
@@ -328,7 +328,7 @@ export function isIncreaseIndent(path) {
 
 const isInsideCallLoop = createTypeChecker([
     ['-: -> !', isInsideCall],
-    '+: parentPath.parentPath -> ForOfStatement',
+    ['+: parentPath.parentPath -> ForOfStatement'],
 ]);
 
 const isStringAndObject = (elements) => {

package/lib/tokenize/expressions/function/class-method.js

@@ -53,7 +53,9 @@ export const ClassMethod = {
         print.space();
         print('__body');
     }),
-    afterSatisfy: () => [noTrailingCommentAndNext],
+    afterSatisfy: () => [
+        noTrailingCommentAndNext,
+    ],
     after(path, {print}) {
         print.linebreak();
     },

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

@@ -23,13 +23,13 @@ const isIndentAfter = createTypeChecker([
 ]);
 
 const isNotInsideExportDefaultWithBody = createTypeChecker([
-    '+: parentPath -> !ExportDefaultDeclaration',
+    ['+: parentPath -> !ExportDefaultDeclaration'],
     ['+: -> !', hasFnBody],
 ]);
 
 const isInsideBlockLike = createTypeChecker([
-    '+: parentPath.parentPath -> TSModuleBlock',
-    '-: parentPath -> !BlockStatement',
+    ['+: parentPath.parentPath -> TSModuleBlock'],
+    ['-: parentPath -> !BlockStatement'],
     ['+: -> !', hasFnBody],
 ]);
 

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

@@ -44,27 +44,27 @@ const isParens = createTypeChecker([isInsideBody, isInsideExpression]);
 const getCallee = (fn) => (a) => fn(a.get('callee'));
 
 const isMemberExpressionCallee = createTypeChecker([
-    '-: parentPath -> !CallExpression',
+    ['-: parentPath -> !CallExpression'],
     ['-: parentPath -> !', getCallee(isMemberExpression)],
     ['+: parentPath', getCallee(isLooksLikeChain)],
 ]);
 
 const isInsideNestedArrayCall = createTypeChecker([
-    isInsideTuple,
-    '-: parentPath -> !ArrayExpression',
-    '-: parentPath.parentPath -> !ArrayExpression',
+    ['+', isInsideTuple],
+    ['-: parentPath -> !ArrayExpression'],
+    ['-: parentPath.parentPath -> !ArrayExpression'],
     ['+: parentPath.parentPath', isInsideCall],
 ]);
 
 const isInsideTupleLike = createTypeChecker([
     ['+', isInsideTuple],
-    '+: parentPath.parentPath.node.elements.0 -> StringLiteral',
+    ['+: parentPath.parentPath.node.elements.0 -> StringLiteral'],
 ]);
 
 export const isManyLines = createTypeChecker([
     ['-', hasNoProperties],
-    '-: parentPath -> ForOfStatement',
-    '+: node.properties.0 -> SpreadElement',
+    ['-: parentPath -> ForOfStatement'],
+    ['+: node.properties.0 -> SpreadElement'],
     ['-', notLastArgInsideCall],
     ['-', isForOf],
     ['-', isIf],

package/lib/tokenize/is.js

@@ -31,6 +31,7 @@ export const isInsideTSModuleBlock = ({parentPath}) => isTSModuleBlock(parentPat
 export const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
 export const isInsideReturn = ({parentPath}) => parentPath.isReturnStatement();
 export const callWithNext = (fn) => (path) => fn(path.getNextSibling());
+export const callWithParent = (fn) => (path) => fn(path.parentPath);
 
 export const isNext = (path) => {
     const next = path.getNextSibling();

package/lib/tokenize/statements/do-while-statement/do-while-statement.js

@@ -16,7 +16,9 @@ export const DoWhileStatement = {
         print(')');
         print(';');
     },
-    afterSatisfy: () => [notLast],
+    afterSatisfy: () => [
+        notLast,
+    ],
     after(path, {print}) {
         print.newline();
     },

package/lib/tokenize/statements/export-declaration/export-default-declaration.js

@@ -20,7 +20,9 @@ export const ExportDefaultDeclaration = {
         traverse(declaration);
         maybe.print(shouldAddSemicolon(declaration), ';');
     },
-    afterSatisfy: () => [isNext],
+    afterSatisfy: () => [
+        isNext,
+    ],
     after(path, {print, maybe}) {
         print.newline();
         maybe.print.newline(!isVarAfterFn(path));

package/lib/tokenize/statements/expression-statement/after-if.js

@@ -16,9 +16,9 @@ function isNotLastOrParentLast(path) {
 const isNextUp = (path) => path.findParent(isNext);
 
 const isTopParentLast = createTypeChecker([
-    '-: parentPath -> !IfStatement',
-    '-: parentPath.parentPath -> !IfStatement',
-    '-: parentPath.parentPath.parentPath -> !IfStatement',
+    ['-: parentPath -> !IfStatement'],
+    ['-: parentPath.parentPath -> !IfStatement'],
+    ['-: parentPath.parentPath.parentPath -> !IfStatement'],
     ['+: parentPath.parentPath.parentPath', isLast],
 ]);
 
@@ -32,7 +32,7 @@ const satisfyAfter = satisfy([
 const isPathIsConsequent = ({node, parentPath}) => node !== parentPath.node.consequent;
 
 const isBeforeElse = createTypeChecker([
-    '-: parentPath -> !IfStatement',
+    ['-: parentPath -> !IfStatement'],
     ['-:', isPathIsConsequent],
     ['+: parentPath.node.alternate', Boolean],
 ]);

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

@@ -26,7 +26,7 @@ const isCallInsideExpression = createTypeChecker([
 ]);
 
 const isNextToAssignmentCall = createTypeChecker([
-    '-: node.expression -> AssignmentExpression',
+    ['-: node.expression -> AssignmentExpression'],
     ['+', callWithNext(isCallInsideExpression)],
 ]);
 
@@ -39,12 +39,12 @@ const isBreaklineAfter = createTypeChecker([
 const isNextStatementWithBlockComment = createTypeChecker([
     '-: node.expression -> !CallExpression',
     '-: node.expression.arguments.0 -> !CallExpression',
-    '+: node.trailingComments.0 -> CommentBlock',
+    '+: node.trailingComments.0 -> 🧨 CommentBlock',
 ]);
 
 const isBreakline = createTypeChecker([
-    isNewlineBetweenSiblings,
-    callWithNext(isIfStatement),
+    ['+', isNewlineBetweenSiblings],
+    ['+', callWithNext(isIfStatement)],
 ]);
 
 const isIndent = createTypeChecker([
@@ -54,7 +54,7 @@ const isIndent = createTypeChecker([
 ]);
 
 export const isIndentAfter = createTypeChecker([
-    '-: node.expression -> !AssignmentExpression',
+    ['-: node.expression -> !AssignmentExpression'],
     ['+', callWithNext(hasLeadingComment)],
 ]);
 

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

@@ -36,7 +36,7 @@ const isStatementNotExpression = (path) => {
 
 const isInsideNestedBody = createTypeChecker([
     ['-: -> !', isInsideBlock],
-    '+: parentPath.parentPath -> BlockStatement',
+    ['+: parentPath.parentPath -> BlockStatement'],
 ]);
 
 const isTopLevel = ({parentPath}) => parentPath.parentPath.isProgram();
@@ -48,7 +48,7 @@ const isLastEmptyInsideBody = createTypeChecker([
     ['-: -> !', isInsideBlock],
     ['-: -> !', isBlockConsequent],
     ['-', isConsequentHasBody],
-    '+: parentPath.parentPath -> FunctionDeclaration',
+    ['+: parentPath.parentPath -> FunctionDeclaration'],
 ]);
 
 export const IfStatement = {
@@ -125,7 +125,9 @@ export const IfStatement = {
         if (isLastEmptyInsideBody(path))
             print.newline();
     },
-    afterSatisfy: () => [isNext],
+    afterSatisfy: () => [
+        isNext,
+    ],
     after: (path, {print}) => {
         print.linebreak();
         markAfter(path);

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

@@ -69,7 +69,9 @@ export const SwitchStatement = {
         if (!isNext(path) && !isLast(path))
             print.newline();
     },
-    afterSatisfy: () => [isNext],
+    afterSatisfy: () => [
+        isNext,
+    ],
     after(path, {print}) {
         print.breakline();
         print.newline();

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

@@ -24,7 +24,9 @@ export const TryStatement = {
             maybe.print.newline(!isNext(path));
         }
     },
-    afterSatisfy: () => [isNext],
+    afterSatisfy: () => [
+        isNext,
+    ],
     after(path, {print}) {
         print.newline();
         

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

@@ -14,6 +14,7 @@ import {
     isInsideProgram,
     isInsideSwitchCase,
     isInsideBody,
+    callWithParent,
 } from '#is';
 import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
 import {isConcatenation} from '../../expressions/binary-expression/concatenate.js';
@@ -36,12 +37,12 @@ const isParentTSModuleBlock = (path) => path.parentPath.isTSModuleBlock();
 const isParentSwitchCase = (path) => path.parentPath.isSwitchCase();
 const isFirstInSwitch = (path) => path.parentPath.get('consequent.0') === path;
 
-const isInsideParentLike = createTypeChecker('path.parentPath', [
+const isInsideParentLike = callWithParent(createTypeChecker([
     'Program',
     'BlockStatement',
     'ExportNamedDeclaration',
     'LabeledStatement',
-]);
+]));
 
 const isNeedSemicolon = createTypeChecker([
     isInsideParentLike,

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

@@ -10,12 +10,13 @@ export const instrument = (typeNames, fn, overrides = {}) => {
     const {
         env = _env,
         coverage = Coverage,
+        instrument = true,
     } = overrides;
     
     const {length} = typeNames;
     const error = Error();
     const location = parseCallLocation(error);
-    const on = env.TYPE_CHECK;
+    const on = instrument && env.TYPE_CHECK;
     const covered = new Set();
     
     if (on && !location.includes('type-checker.spec.js'))
@@ -36,3 +37,4 @@ export const instrument = (typeNames, fn, overrides = {}) => {
 };
 
 export const getCoverage = () => Coverage;
+

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

@@ -22,6 +22,14 @@ export function parseTypeNames(typeNames) {
     
     if (isArray(typeNames)) {
         for (const typeName of typeNames) {
+            if (isArray(typeName) && typeName.length === 1) {
+                const [first] = typeName;
+                const tuple = createTuple(first);
+                
+                tuples.push(tuple);
+                continue;
+            }
+            
             if (isArray(typeName)) {
                 tuples.push(typeName);
                 continue;

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

@@ -1,5 +1,5 @@
 import {jessy} from 'jessy';
-import {instrument} from '#type-checker/instrument';
+import {instrument as _instrument} from '#type-checker/instrument';
 import {parseOperation, parseTypeNames} from './parsers.js';
 import {equal, maybeCall} from './comparators.js';
 
@@ -8,26 +8,12 @@ const SKIP = [
     false,
 ];
 
-export const createTypeChecker = (deepness, typeNames) => {
-    if (!typeNames) {
-        typeNames = deepness;
-        deepness = '';
-    }
-    
+export const createTypeChecker = (typeNames, overrides = {}) => {
+    const {
+        instrumentCoverage = _instrument,
+    } = overrides;
     const tuples = parseTypeNames(typeNames);
-    
-    return instrument(typeNames, (path, options) => {
-        let i = deepness.split('.').length;
-        
-        while (--i)
-            path = path?.parentPath;
-        
-        if (!path)
-            return [
-                Infinity,
-                false,
-            ];
-        
+    const typeChecker = (path, options) => {
         for (const [index, [operation, typeName]] of tuples.entries()) {
             const [result, selector, not] = parseOperation(operation);
             let currentPath = path;
@@ -48,5 +34,7 @@ export const createTypeChecker = (deepness, typeNames) => {
         }
         
         return SKIP;
-    });
+    };
+    
+    return instrumentCoverage(typeNames, typeChecker, overrides);
 };

package/lib/tokenize/typescript/namespace/ts-module-declaration.js

@@ -15,7 +15,9 @@ export const TSModuleDeclaration = {
         print.space();
         print('__body');
     }),
-    afterSatisfy: () => [isNext],
+    afterSatisfy: () => [
+        isNext,
+    ],
     after(path, {print}) {
         print.newline();
         print.newline();

package/lib/tokenize/typescript/ts-export-assignment/ts-export-assignment.js

@@ -6,7 +6,9 @@ export const TSExportAssignment = {
         print('__expression');
         print(';');
     },
-    afterSatisfy: () => [isNext],
+    afterSatisfy: () => [
+        isNext,
+    ],
     after: (path, {print}) => {
         print.newline();
     },

package/package.json

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