@putout/printer 18.8.5 → 18.9.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2026.03.20, v18.9.0
+
+feature:
+- 2840175e @putout/printer: JSXElement: apply type-checker
+- 2c116629 @putout/printer: JSXElement: indent
+
+2026.03.20, v18.8.6
+
+feature:
+- 9e0406e2 @putout/printer: type-checker: maybeCutOptions
+
 2026.03.20, v18.8.5
 
 feature:

package/lib/tokenize/expressions/object-pattern/should-add-new-line.js

@@ -32,13 +32,10 @@ function hasPropertyLeadingComment(path) {
     return false;
 }
 
-const cutOptions = (fn) => (a) => fn(a);
-const isFunctionLike = cutOptions(isFunction);
-
 const isFunctionParam = callWithParent(createTypeChecker([
-    ['+', isFunctionLike],
+    ['+', isFunction],
     ['-: -> !AssignmentPattern'],
-    ['+: parentPath', isFunctionLike],
+    ['+: parentPath', isFunction],
 ]));
 
 const isOneOfIdentifiersHasMoreLength = createTypeChecker([
@@ -68,7 +65,9 @@ function isCoupleAssigns(path) {
     if (isFunctionParam(path))
         return false;
     
-    const properties = path.node.properties
+    const properties = path
+        .node
+        .properties
         .filter(isObjectProperty)
         .map(getValue)
         .filter(isAssignmentPattern);

package/lib/tokenize/jsx/indent.js

@@ -0,0 +1,33 @@
+import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
+
+const {isFunction} = types;
+
+export function isNeedIndent(path) {
+    if (hasComplexAttribute(path))
+        return false;
+    
+    const insideFn = path.parentPath.isArrowFunctionExpression();
+    const insideJSX = path.parentPath.isJSXElement();
+    const insideCall = path.parentPath.parentPath.isCallExpression();
+    
+    return insideJSX || insideFn && insideCall;
+}
+
+const isComplexAttribute = createTypeChecker([
+    ['+: -> JSXSpreadAttribute'],
+    ['-: node.value -> !JSXExpressionContainer'],
+    ['+: parentPath.node.attributes.length', '>', 1],
+    ['+: node.value.expression', isFunction],
+]);
+
+function hasComplexAttribute(path) {
+    const attributes = path.get('openingElement.attributes');
+    
+    for (const attribute of attributes) {
+        if (isComplexAttribute(attribute))
+            return true;
+    }
+    
+    return false;
+}

package/lib/tokenize/jsx/jsx-element.js

@@ -1,13 +1,25 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
+import {isNeedIndent} from './indent.js';
+
+const isDeeplyNestedJSX = ({parentPath}) => {
+    return isJSXElement(parentPath.parentPath?.parentPath?.parentPath);
+};
+
+const condition = createTypeChecker([
+    '+: node.extra.parenthesized -> +',
+    '+: parentPath -> ReturnStatement',
+    '+: parentPath -> ParenthesizedExpression',
+    '+: parentPath -> ArrowFunctionExpression',
+    '+: parentPath -> VariableDeclarator',
+]);
 
 const {
     isJSXElement,
-    isJSXExpressionContainer,
-    isFunction,
-    isJSXSpreadAttribute,
+    isArrowFunctionExpression,
 } = types;
 
-const isInsideArrow = ({parentPath}) => parentPath.isArrowFunctionExpression();
+const isInsideArrow = ({parentPath}) => isArrowFunctionExpression(parentPath);
 
 export const JSXElement = {
     condition,
@@ -36,7 +48,7 @@ export const JSXElement = {
     },
     after(path, {write, indent, maybe}) {
         const {leadingComments} = path.node;
-        const isJSX = isJSXElement(path.parentPath.parentPath?.parentPath?.parentPath);
+        const isJSX = isDeeplyNestedJSX(path);
         
         if (isJSX) {
             write.breakline();
@@ -49,51 +61,3 @@ export const JSXElement = {
         maybe.write(!leadingComments?.length, ')');
     },
 };
-
-function condition(path) {
-    if (path.parentPath.isReturnStatement())
-        return true;
-    
-    if (path.parentPath.isParenthesizedExpression())
-        return true;
-    
-    if (path.node.extra?.parenthesized)
-        return true;
-    
-    if (path.parentPath.isArrowFunctionExpression())
-        return true;
-    
-    return path.parentPath.isVariableDeclarator();
-}
-
-function hasComplexAttribute(path) {
-    const {attributes} = path.node.openingElement;
-    
-    for (const attribute of attributes) {
-        const {value} = attribute;
-        
-        if (isJSXSpreadAttribute(attribute))
-            return true;
-        
-        if (!isJSXExpressionContainer(value))
-            continue;
-        
-        const {expression} = value;
-        
-        if (isFunction(expression))
-            return true;
-    }
-    
-    return false;
-}
-
-function isNeedIndent(path) {
-    if (hasComplexAttribute(path))
-        return false;
-    
-    const insideFn = path.parentPath.isArrowFunctionExpression();
-    const insideJSX = path.parentPath.isJSXElement();
-    const insideCall = path.parentPath.parentPath.isCallExpression();
-    
-    return insideJSX || insideFn && insideCall;
-}

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

@@ -1,3 +1,5 @@
+import {types} from '@putout/babel';
+
 const isFn = (a) => typeof a === 'function';
 const isString = (a) => typeof a === 'string';
 const maybeNot = (not, a) => not ? !a : a;
@@ -18,10 +20,19 @@ export const maybeCall = (fn, not, a, options) => {
     if (!isFn(fn))
         return false;
     
-    const result = fn(a, options);
+    const result = maybeCutOptions(fn, a, options);
     
     if (not)
         return !result;
     
     return result;
 };
+
+function maybeCutOptions(fn, a, options) {
+    const {name} = fn;
+    
+    if (types[name] === fn)
+        return fn(a);
+    
+    return fn(a, options);
+}

package/package.json

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