@putout/printer 18.39.0 → 18.40.1

package/ChangeLog

@@ -1,3 +1,13 @@
+2026.08.21, v18.40.1
+
+feature:
+- e137edf2 @putout/printer/ CallExpression: simplify
+
+2026.08.21, v18.40.0
+
+feature:
+- 0050ee83 @putout/printer: __putout_processor_sql: add support
+
 2026.08.21, v18.39.0
 
 feature:

package/lib/printer.js

@@ -1,6 +1,7 @@
 import {tokenize} from './tokenize/tokenize.js';
 import {printTokens} from './print-tokens/index.js';
 import {maybeJSON} from './json.js';
+import {maybeSQL} from './sql.js';
 
 export {maybeVisitor} from './tokenize/maybe/index.js';
 export * as visitors from './tokenize/visitors.js';
@@ -8,7 +9,11 @@ export * as visitors from './tokenize/visitors.js';
 export const print = (ast, overrides = {}) => {
     check(ast);
     
-    const options = maybeJSON(ast, overrides);
+    const options = {
+        ...maybeJSON(ast, overrides),
+        ...maybeSQL(ast, overrides),
+    };
+    
     const tokens = tokenize(ast, options);
     
     return printTokens(tokens);

package/lib/sql.js

@@ -0,0 +1,44 @@
+import {types} from '@putout/babel';
+import {isSQL} from '@putout/operator-json';
+
+const {
+    isCallExpression,
+    isIdentifier,
+} = types;
+
+export const maybeSQL = (ast, overrides) => {
+    if (isASTSQL(ast))
+        return {
+            ...overrides,
+            semantics: {
+                ...overrides?.semantics,
+                maxArgsInOneLine: 1,
+            },
+        };
+    
+    return overrides;
+};
+
+function isASTSQL(ast) {
+    const {program} = ast;
+    
+    if (!program)
+        return false;
+    
+    const {body} = ast.program;
+    
+    if (!body.length)
+        return false;
+    
+    const {expression} = ast.program.body[0];
+    
+    if (!isCallExpression(expression))
+        return false;
+    
+    const {callee} = expression;
+    
+    if (!isIdentifier(callee))
+        return false;
+    
+    return isSQL(callee.name);
+}

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.39.0",
+  "version": "18.40.1",
   "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/call-expression/call-expression-with-max-args.js

@@ -1,18 +0,0 @@
-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) {
-        write.breakline();
-        traverse(arg);
-        write(',');
-    }
-    
-    indent.dec();
-    write.breakline();
-    write(')');
-};