@putout/printer 18.40.0 → 18.40.2

package/ChangeLog

@@ -1,3 +1,13 @@
+2026.08.22, v18.40.2
+
+fix:
+- 8134ac8f @putout/printer: json, sql
+
+2026.08.21, v18.40.1
+
+feature:
+- e137edf2 @putout/printer/ CallExpression: simplify
+
 2026.08.21, v18.40.0
 
 feature:

package/lib/printer.js

@@ -7,12 +7,12 @@ export {maybeVisitor} from './tokenize/maybe/index.js';
 export * as visitors from './tokenize/visitors.js';
 
 export const print = (ast, overrides = {}) => {
+    let options = overrides;
     check(ast);
     
-    const options = {
-        ...maybeJSON(ast, overrides),
-        ...maybeSQL(ast, overrides),
-    };
+    for (const maybe of [maybeJSON, maybeSQL]) {
+        options = maybe(ast, options);
+    }
     
     const tokens = tokenize(ast, options);
     

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

@@ -1,8 +1,7 @@
 import {types} from '@putout/babel';
-import {exists, isInsideCall} from '#is';
+import {isInsideCall} from '#is';
 import {maybeParens} from '#maybe-parens';
 import {createTypeChecker} from '#type-checker';
-import {CallExpressionWithMaxArgs} from './call-expression-with-max-args.js';
 
 const {
     isIdentifier,
@@ -21,62 +20,64 @@ const parseArgs = (path) => {
     return argsPath;
 };
 
-function isMaxArgs(path, {maxArgsInOneLine}) {
-    const args = parseArgs(path);
-    
-    const [first] = args;
-    
-    if (isArrayExpression(first))
-        return false;
-    
-    return args.length >= maxArgsInOneLine;
-}
+const getMaxArgsInOneLine = (path, {maxArgsInOneLine}) => maxArgsInOneLine;
+const firstArgIsArray = (path) => isArrayExpression(path.node?.arguments?.[0]);
+
+const isMaxArgs = createTypeChecker([
+    ['-', firstArgIsArray],
+    ['+: node.arguments.length', '>=', getMaxArgsInOneLine],
+]);
 
-const isNeedsNewLine = createTypeChecker([
+const isMultiline = createTypeChecker([
     ['-: -> !', tooLong],
     ['+', isInsideCall],
 ]);
 
 export const CallExpression = maybeParens((path, printer, semantics) => {
-    if (isMaxArgs(path, semantics))
-        return CallExpressionWithMaxArgs(path, printer);
-    
-    const {
-        indent,
-        print,
-        maybe,
-        traverse,
-    } = printer;
+    const {print, maybe} = printer;
     
     const args = parseArgs(path);
-    const needsNewline = isNeedsNewLine(path, semantics);
     
-    const callee = path.get('callee');
-    const typeParameters = path.get('typeArguments');
+    print('__callee');
+    print('__typeArguments');
+    maybe.print(path.node.optional, '?.');
     
-    traverse(callee);
+    print('(');
     
-    if (exists(typeParameters))
-        traverse(typeParameters);
+    const maxArgs = isMaxArgs(path, semantics);
+    const multiline = maxArgs || isMultiline(path, semantics);
     
-    if (path.node.optional)
-        print('?.');
+    printArgs(args, printer, {
+        maxArgs,
+        multiline,
+    });
     
-    print('(');
+    print(')');
+});
+
+export const OptionalCallExpression = CallExpression;
+
+function printArgs(args, printer, {maxArgs, multiline}) {
+    const {
+        indent,
+        print,
+        maybe,
+    } = printer;
     
     const n = args.length - 1;
     
-    maybe.indent.inc(needsNewline);
+    maybe.indent.inc(multiline);
     
     for (const [i, arg] of args.entries()) {
-        const isObject = isObjectExpression(arg);
-        
-        if (needsNewline && !isObject && n)
-            print.breakline();
+        if (multiline)
+            if (maxArgs && isArrayExpression(arg))
+                print.space();
+            else if (n || maxArgs && !isObjectExpression(arg))
+                print.breakline();
         
         print(arg);
         
-        if (needsNewline && n) {
+        if (multiline && (n || maxArgs)) {
             print(',');
             continue;
         }
@@ -87,15 +88,11 @@ export const CallExpression = maybeParens((path, printer, semantics) => {
         }
     }
     
-    if (needsNewline) {
+    if (multiline) {
         indent.dec();
-        maybe.print.breakline(n);
+        maybe.print.breakline(n || maxArgs);
     }
-    
-    print(')');
-});
-
-export const OptionalCallExpression = CallExpression;
+}
 
 function tooLong(path) {
     const args = parseArgs(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "18.40.0",
+  "version": "18.40.2",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -79,6 +79,8 @@
     "@babel/parser": "^8.0.0",
     "@putout/eslint": "^6.0.0",
     "@putout/eslint-flat": "^4.0.0",
+    "@putout/operator-filesystem": "^11.2.1",
+    "@putout/operator-match-files": "^12.4.1",
     "@putout/plugin-minify": "^12.0.0",
     "@putout/plugin-printer": "^8.0.0",
     "@putout/plugin-promises": "^20.0.0",

package/lib/tokenize/expressions/call-expression/call-expression-with-max-args.js

@@ -1,27 +0,0 @@
-import {types} from '@putout/babel';
-
-const {isArrayExpression} = types;
-
-export const CallExpressionWithMaxArgs = (path, {write, indent, traverse}) => {
-    const {name} = path.node.callee;
-    const args = path.get('arguments');
-    
-    write(name);
-    write('(');
-    indent.inc();
-    
-    for (const arg of args) {
-        if (isArrayExpression(arg))
-            write.space();
-        else
-            write.breakline();
-        
-        traverse(arg);
-        write(',');
-    }
-    
-    indent.dec();
-    write.breakline();
-    write(')');
-};
-