@putout/printer 18.0.8 → 18.0.10

package/ChangeLog

@@ -1,3 +1,17 @@
+2026.03.05, v18.0.10
+
+feature:
+- d29c6de @putout/printer: ObjectExpression: isInsideTupleLike: simplify
+- e4ee1c0 @putout/printer: ObjectExpression: isMemberExpressionCallee: simplify
+- e1df5a9 @putout/printer: isThirdObjectInsideArray: rm
+- c90efb6 ObjectExpression: isInsideExpression: reuse from NewExpression
+- 84b86bb @putout/printer: VariableDeclaration: isInsideBody: reuse in ObjectExpression
+
+2026.03.05, v18.0.9
+
+feature:
+- 5b851ca @putout/printer: VariableDeclaration: isInsideBody: simplify
+
 2026.03.05, v18.0.8
 
 feature:

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

@@ -1,13 +1,12 @@
 import {types} from '@putout/babel';
-import {exists} from '#is';
+import {
+    exists,
+    isInsideExpression,
+} from '#is';
 import {isMarkedAfter} from '#mark';
 
-const {
-    isExpressionStatement,
-    isMemberExpression,
-} = types;
+const {isMemberExpression} = types;
 
-const isInsideExpressionStatement = ({parentPath}) => isExpressionStatement(parentPath);
 const notFirst = ({parentPath}) => exists(parentPath.getPrevSibling());
 const isInsideMember = ({parentPath}) => isMemberExpression(parentPath);
 
@@ -22,7 +21,7 @@ const getPrev = ({parentPath}) => {
 
 export const NewExpression = {
     beforeIf(path) {
-        if (!isInsideExpressionStatement(path))
+        if (!isInsideExpression(path))
             return false;
         
         const [exists, prev] = getPrev(path);

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

@@ -1,4 +1,5 @@
 import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
 import {
     isCoupleLines,
     isForOf,
@@ -9,51 +10,41 @@ import {
     hasLeadingComment,
     exists,
     isInsideCall,
+    isInsideBody,
+    isInsideExpression,
 } from '#is';
 import {parseComments} from '../../comment/comment.js';
 import {isInsideTuple} from './is-inside-tuple.js';
 import {isLooksLikeChain} from '../member-expression/is-looks-like-chain.js';
-import {isThirdObjectInsideArray} from './is-third-object-inside-array.js';
 
 const {
-    isStringLiteral,
-    isArrayExpression,
     isSpreadElement,
+    isMemberExpression,
 } = types;
 
-const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
 const isLogical = (path) => path.get('argument').isLogicalExpression();
 const isValue = (path) => path.get('properties.0.value').node;
-const isParentExpression = (path) => path.parentPath.isExpressionStatement();
 
-const isMemberExpressionCallee = ({parentPath}) => {
-    if (!parentPath.isCallExpression())
-        return false;
-    
-    const callee = parentPath.get('callee');
-    
-    if (!callee.isMemberExpression())
-        return false;
-    
-    return isLooksLikeChain(callee);
-};
+const isParens = createTypeChecker([isInsideBody, isInsideExpression]);
+const getCallee = (fn) => (a) => fn(a.get('callee'));
 
-function isInsideNestedArrayCall({parentPath}) {
-    if (!isArrayExpression(parentPath))
-        return false;
-    
-    if (!isArrayExpression(parentPath.parentPath))
-        return false;
-    
-    return isInsideCall(parentPath.parentPath);
-}
+const isMemberExpressionCallee = createTypeChecker([
+    '-: parentPath -> !CallExpression',
+    ['-: parentPath -> !', getCallee(isMemberExpression)],
+    ['+: parentPath', getCallee(isLooksLikeChain)],
+]);
 
-function isInsideNestedTuple({parentPath}) {
-    const {elements} = parentPath.parentPath.node;
-    const [first] = elements;
-    
-    return isStringLiteral(first);
-}
+const isInsideNestedArrayCall = createTypeChecker([
+    isInsideTuple,
+    '-: parentPath -> !ArrayExpression',
+    '-: parentPath.parentPath -> !ArrayExpression',
+    ['+: parentPath.parentPath', isInsideCall],
+]);
+
+const isInsideTupleLike = createTypeChecker([
+    ['+', isInsideTuple],
+    '+: parentPath.parentPath.node.elements.0 -> StringLiteral',
+]);
 
 export const ObjectExpression = (path, printer, semantics) => {
     const {trailingComma} = semantics;
@@ -63,7 +54,7 @@ export const ObjectExpression = (path, printer, semantics) => {
         indent,
     } = printer;
     
-    const insideNestedArrayCall = isInsideTuple(path) || isInsideNestedArrayCall(path) || isThirdObjectInsideArray(path);
+    const insideNestedArrayCall = isInsideNestedArrayCall(path);
     
     maybe.indent.inc(!insideNestedArrayCall);
     
@@ -114,7 +105,7 @@ export const ObjectExpression = (path, printer, semantics) => {
     if (!insideNestedArrayCall) {
         indent.dec();
         maybe.indent(manyLines);
-    } else if (isInsideTuple(path) || isInsideNestedTuple(path)) {
+    } else if (isInsideTupleLike(path)) {
         indent.dec();
         indent();
         indent.inc();
@@ -182,10 +173,3 @@ export function isOneLine(path) {
     
     return !isValue(path);
 }
-
-function isParens(path) {
-    if (isBodyOfArrow(path))
-        return true;
-    
-    return isParentExpression(path);
-}

package/lib/tokenize/is.js

@@ -16,11 +16,14 @@ const {
     isBlockStatement,
     isTSModuleBlock,
     isSwitchCase,
+    isExpressionStatement,
 } = types;
 
 export const isInsideProgram = (path) => isProgram(path.parentPath);
 export const isInsideBlock = (path) => isBlockStatement(path.parentPath);
 export const isInsideSwitchCase = (path) => isSwitchCase(path.parentPath);
+export const isInsideBody = ({node, parentPath}) => node === parentPath.node.body;
+export const isInsideExpression = ({parentPath}) => isExpressionStatement(parentPath);
 
 export const isInsideTSModuleBlock = ({parentPath}) => isTSModuleBlock(parentPath);
 

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

@@ -13,6 +13,7 @@ import {
     isInsideTSModuleBlock,
     isInsideProgram,
     isInsideSwitchCase,
+    isInsideBody,
 } from '#is';
 import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
 import {isConcatenation} from '../../expressions/binary-expression/concatenate.js';
@@ -21,8 +22,6 @@ import {maybeDeclare} from '../../maybe/maybe-declare.js';
 
 const {isExportDeclaration} = types;
 
-const isInsideBody = (path) => path.node === path.parentPath.node.body;
-
 const isInsideBlockLike = createTypeChecker([
     isInsideProgram,
     isInsideBlock,

package/package.json

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

package/lib/tokenize/expressions/object-expression/is-third-object-inside-array.js

@@ -1,16 +0,0 @@
-import {types} from '@putout/babel';
-
-const {
-    isArrayExpression,
-    isCallExpression,
-    isIdentifier,
-} = types;
-
-export const isThirdObjectInsideArray = ({parentPath}) => {
-    if (!isArrayExpression(parentPath))
-        return false;
-    
-    const [, second] = parentPath.node.elements;
-    
-    return isCallExpression(second) && !!isIdentifier(second);
-};