prettier-plugin-hug-call-arguments 0.1.5 → 0.1.7

package/README.md

@@ -120,16 +120,24 @@ db.updateTable("User").set({
 ## How it works
 
 This plugin wraps Prettier's built-in `estree` printer and only overrides the
-`print` step for `CallExpression` nodes that match one of two narrow, specific
-shapes.
+`print` step for `CallExpression` and `ArrowFunctionExpression` nodes that
+match one of a few narrow, specific shapes.
 
 **Hugging a call-wrapped callback:**
 
 - the callee is a plain identifier or non-computed member chain (`foo`,
   `a.b.c`) — chained calls (`a().b()`) are left untouched
-- the last argument is itself a call whose own last argument is a
-  function/object/array literal (looked through recursively)
-- every earlier argument fits on the opening line
+- either the *last* argument is itself a call whose own last argument is a
+  function/object/array literal (looked through recursively, so a chain of
+  wrappers like `a(b(cb))` is still found — the common `catchAsync(cb)` case),
+  or, for a 2-argument call whose second argument is short and simple (a
+  literal or identifier), the *first* argument is such a wrapping call (the
+  lodash-style `uniqueBy(collection, "key")` shape)
+- the resulting line actually fits `printWidth`; if it doesn't (most often
+  because a wrapping call itself sits inside *another* wrapping call), this
+  falls back to Prettier's default printing for the outer call — inner calls
+  still get their own independent chance to hug once Prettier places them at
+  their own, shallower indentation
 - there's no blank line between arguments, no comments on the relevant
   nodes, and no TS type arguments
 

package/dist/index.d.ts

@@ -24,6 +24,10 @@ interface ESNode {
     name?: string;
     arguments?: ESNode[];
     body?: ESNode;
+    params?: ESNode[];
+    async?: boolean;
+    returnType?: unknown;
+    predicate?: unknown;
 }
 declare const plugin: Plugin<ESNode>;
 export = plugin;

package/dist/index.js

@@ -59,7 +59,7 @@ const doc_1 = require("prettier/doc");
 // what `require`/interop resolves to, and its printer object is what we
 // spread and delegate to for every node we don't special-case.
 const estree = __importStar(require("prettier/plugins/estree"));
-const { group, conditionalGroup, indent, hardline, line, softline, join, ifBreak, breakParent, } = doc_1.builders;
+const { group, indent, line, softline, join, ifBreak, breakParent } = doc_1.builders;
 const { willBreak } = doc_1.utils;
 // `estree.printers.estree` is typed as `Printer<any>` by Prettier, which is
 // assignable to `Printer<ESNode>` on its own — no cast needed.
@@ -82,9 +82,37 @@ function isHuggableFunction(node) {
     }
     return false;
 }
+/**
+ * A short, unbreakable-looking companion argument — the kind lodash-style
+ * `uniqueBy(collection, iteratee)` APIs take alongside the huggable
+ * collection argument. Deliberately conservative: only literals and plain
+ * identifiers qualify, so this plugin never has to guess whether some
+ * arbitrary expression will break.
+ */
+function isSimpleArg(node) {
+    if (!node || hasComment(node)) {
+        return false;
+    }
+    return (node.type === "StringLiteral" ||
+        node.type === "NumericLiteral" ||
+        node.type === "BooleanLiteral" ||
+        node.type === "NullLiteral" ||
+        node.type === "Identifier" ||
+        node.type === "TemplateLiteral");
+}
 /**
  * Like Prettier's internal `couldExpandArg`, but also looks through calls
  * that merely wrap a huggable function, e.g. `catchAsync(async () => {})`.
+ * Only ever looks through the *last* argument, arbitrarily deep — so a chain
+ * of wrappers like `a(b(c(cb)))` is still found. Deliberately does *not*
+ * also recurse through the lodash-style "first argument wraps, second is
+ * simple" shape here: that's only applied at the top, in
+ * `findExpandableArgIndex`, for the call actually being printed. Letting it
+ * recurse here would also make an *outer* call think it should hug a
+ * wrapper two levels down, forcing everything onto one line with no way to
+ * tell whether that line will actually fit once it's for real embedded
+ * after an assignment, an `await`, or another wrapping call — see
+ * `fitsWhenFlattened`'s column-0 blind spot below.
  */
 function couldExpandArg(node, depth = 0) {
     if (!node || depth > 4) {
@@ -104,6 +132,33 @@ function couldExpandArg(node, depth = 0) {
     }
     return false;
 }
+/**
+ * Finds which argument of a call is the one worth hugging: the last
+ * argument when it's itself a wrapping call that leads to something
+ * huggable, or — for a 2-argument call whose second argument is short and
+ * simple — the first argument instead. Returns `undefined` when neither
+ * shape matches, so the caller falls back to Prettier's default printing.
+ */
+function findExpandableArgIndex(args) {
+    const isWrappingCall = (arg) => arg !== undefined &&
+        !hasComment(arg) &&
+        arg.type === "CallExpression" &&
+        !arg.optional &&
+        Boolean(arg.arguments) &&
+        (arg.arguments?.length ?? 0) > 0 &&
+        couldExpandArg(arg);
+    const last = args.at(-1);
+    if (isWrappingCall(last)) {
+        return args.length - 1;
+    }
+    if (args.length === 2) {
+        const [first, second] = args;
+        if (isWrappingCall(first) && isSimpleArg(second)) {
+            return 0;
+        }
+    }
+    return undefined;
+}
 /**
  * Only intervene for plain-looking callees (`foo(...)`, `a.b.c(...)`) so we
  * never fight Prettier's member/call-chain printing (`a().b().c(cb)`).
@@ -139,6 +194,21 @@ function wouldBreakStandalone(doc, options) {
     }
     return doc_1.printer.printDocToString(doc, options).formatted.includes("\n");
 }
+/**
+ * Prettier's own doc printer doesn't reliably re-check `printWidth` for
+ * plain content that comes *after* a forced break inside a conditionalGroup
+ * alternative — this is the same class of limitation their own
+ * `isHopefullyShortCallArgument` hack works around (see
+ * https://github.com/prettier/prettier/issues/2456). So rather than trust
+ * `conditionalGroup` to reject an overflowing candidate on its own, render it
+ * standalone and check every line ourselves.
+ */
+function fitsWhenFlattened(doc, options) {
+    const { formatted } = doc_1.printer.printDocToString(doc, options);
+    return formatted
+        .split("\n")
+        .every((line) => line.length <= options.printWidth);
+}
 function tryHugWrappedCallback(path, options, print) {
     const { node } = path;
     if (node.type !== "CallExpression" || node.optional) {
@@ -151,14 +221,8 @@ function tryHugWrappedCallback(path, options, print) {
     if (args.length === 0 || !node.callee || !isSimpleCallee(node.callee)) {
         return undefined;
     }
-    const lastArg = args.at(-1);
-    if (!lastArg ||
-        hasComment(lastArg) ||
-        lastArg.type !== "CallExpression" ||
-        lastArg.optional ||
-        !lastArg.arguments ||
-        lastArg.arguments.length === 0 ||
-        !couldExpandArg(lastArg)) {
+    const expandIndex = findExpandableArgIndex(args);
+    if (expandIndex === undefined) {
         return undefined;
     }
     for (let i = 0; i < args.length - 1; i++) {
@@ -171,32 +235,95 @@ function tryHugWrappedCallback(path, options, print) {
         }
     }
     const printedArgs = path.map(print, "arguments");
-    const headDocs = printedArgs.slice(0, -1);
-    const lastDoc = printedArgs.at(-1);
-    // If the earlier args don't fit on one line, or the wrapped callback
+    const expandDoc = printedArgs[expandIndex];
+    const otherDocs = printedArgs.filter((_, i) => i !== expandIndex);
+    // If the other args don't fit on one line, or the wrapped callback
     // wouldn't break anyway, Prettier's default output is already fine.
-    if (lastDoc === undefined ||
-        headDocs.some((doc) => wouldBreakStandalone(doc, options)) ||
-        !wouldBreakStandalone(lastDoc, options)) {
+    if (expandDoc === undefined ||
+        otherDocs.some((doc) => wouldBreakStandalone(doc, options)) ||
+        !wouldBreakStandalone(expandDoc, options)) {
+        return undefined;
+    }
+    const beforeDocs = printedArgs.slice(0, expandIndex);
+    const afterDocs = printedArgs.slice(expandIndex + 1);
+    const beforeWithCommas = beforeDocs.flatMap((doc) => [doc, ", "]);
+    const afterWithCommas = afterDocs.flatMap((doc) => [", ", doc]);
+    const primaryDoc = [
+        print("callee"),
+        "(",
+        ...beforeWithCommas,
+        group(expandDoc, { shouldBreak: true }),
+        ...afterWithCommas,
+        ")",
+    ];
+    // Rendering this standalone starts it at column 0, blind to whatever real
+    // prefix (an assignment, an `await`, an outer wrapping call) it's actually
+    // embedded after — so this under-counts the true column and can pass a
+    // candidate that will genuinely overflow once placed for real. It's still
+    // the right conservative default: it correctly rejects the case that
+    // matters most (this call's own head arguments are too long to share the
+    // opening line), and erring toward Prettier's own default breakout is
+    // always a safe fallback.
+    if (!fitsWhenFlattened(primaryDoc, options)) {
+        return undefined;
+    }
+    return [breakParent, primaryDoc];
+}
+/**
+ * Handles an arrow function with a concise (non-block) body that's itself a
+ * call needing multi-line printing, e.g.:
+ *
+ *   const f = (data: Job) => pgBoss.then((boss) => {
+ *     ...
+ *   });
+ *
+ * Prettier hugs a concise body directly after `=>` for several node types
+ * (object/array literals, JSX, template literals, ...) but not for a plain
+ * `CallExpression` — it always inserts a hardline after `=>` and indents the
+ * call onto its own line instead, even when the call's own last argument is
+ * already going to hug and break internally regardless. This reproduces
+ * Prettier's own arrow-head printing for the narrow, common shape (no type
+ * parameters, return type, or predicate; default `arrowParens`) and keeps
+ * the body on the same line as `=>` instead.
+ */
+function tryHugArrowBody(path, options, print) {
+    const { node } = path;
+    if (node.type !== "ArrowFunctionExpression" ||
+        hasComment(node) ||
+        node.typeParameters ||
+        node.returnType ||
+        node.predicate ||
+        options.arrowParens === "avoid") {
+        return undefined;
+    }
+    const body = node.body;
+    if (!body || body.type !== "CallExpression" || hasComment(body)) {
+        return undefined;
+    }
+    const bodyDoc = print("body");
+    if (!wouldBreakStandalone(bodyDoc, options)) {
         return undefined;
     }
-    const headWithCommas = headDocs.flatMap((doc) => [doc, ", "]);
     const trailingComma = options.trailingComma === "all" ? "," : "";
-    const allArgsBrokenOut = () => group([
+    const paramsDoc = group([
         "(",
-        indent([hardline, join([",", hardline], printedArgs)]),
-        trailingComma,
-        hardline,
+        indent([softline, join([",", line], path.map(print, "params"))]),
+        ifBreak(trailingComma),
+        softline,
         ")",
-    ], { shouldBreak: true });
-    return [
-        breakParent,
-        print("callee"),
-        conditionalGroup([
-            ["(", ...headWithCommas, group(lastDoc, { shouldBreak: true }), ")"],
-            allArgsBrokenOut(),
-        ]),
+    ]);
+    const primaryDoc = [
+        node.async ? "async " : "",
+        paramsDoc,
+        " => ",
+        bodyDoc,
     ];
+    // Same column-0 blind spot as `tryHugWrappedCallback` (see its comment) —
+    // conservative, but errs toward Prettier's own default when unsure.
+    if (!fitsWhenFlattened(primaryDoc, options)) {
+        return undefined;
+    }
+    return [breakParent, primaryDoc];
 }
 const MAX_CHAIN_LINKS = 6;
 /**
@@ -286,22 +413,6 @@ function collectChainLinks(path, print, options, depth) {
     const baseDoc = path.call(print, "callee", "object");
     return { links: [link], baseDoc };
 }
-/**
- * Each link's own argument list already breaks correctly on its own — via
- * Prettier's normal, width-aware group mechanics — because there's no group
- * wrapping the whole chain forcing anything. The one thing that mechanism
- * can't see is a chain of many short, individually-non-breaking links whose
- * *combined* length still overflows `printWidth` (nothing internal to break
- * on). So render the assembled candidate standalone and check every line
- * before committing to it, falling back to Prettier's own chain layout if
- * it doesn't fit.
- */
-function fitsWhenFlattened(doc, options) {
-    const { formatted } = doc_1.printer.printDocToString(doc, options);
-    return formatted
-        .split("\n")
-        .every((line) => line.length <= options.printWidth);
-}
 /**
  * Handles method chains like `db.updateTable("User").set({ ... }).where(
  * "id", "=", user.id).execute()`, where Prettier's default chain printer
@@ -348,6 +459,7 @@ const plugin = {
             ...estreePrinter,
             print(path, options, print, args) {
                 const hugged = tryHugWrappedCallback(path, options, print) ??
+                    tryHugArrowBody(path, options, print) ??
                     tryHugChainArgument(path, options, print);
                 return hugged === undefined
                     ? estreePrinter.print(path, options, print, args)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-hug-call-arguments",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Prettier plugin: hug the last call argument even when it's wrapped in another call, e.g. app.delete(\"/x\", catchAsync(async (req, res) => { ... })). Fixes https://github.com/prettier/prettier/issues/11080",
   "author": "soso tsertsvadze",
   "license": "MIT",