prettier-plugin-hug-call-arguments 0.1.9 → 0.1.11

package/README.md

@@ -180,6 +180,28 @@ regardless of the original formatting.
 - there's no blank line between arguments, no comments on the relevant
   nodes, and no TS type arguments
 
+**Hugging a call whose sole argument needs it:**
+
+```js
+// input
+firstValueFrom(client.getX({ fileKey: data.fileKey, frameCount: FRAME_COUNT }));
+
+// with this plugin
+firstValueFrom(client.getX({
+  fileKey: data.fileKey,
+  frameCount: FRAME_COUNT,
+}));
+```
+
+- the call has exactly one argument, and it's directly an object or array
+  literal that needs multi-line printing
+- Prettier already hugs this shape reliably *in isolation*, but its own
+  "does the opening line fit" check can still give up and break the call's
+  own parens too once this plugin has fused several outer layers together
+  (pushing the real column deeper than Prettier expected) — there's
+  essentially never a readability win to that fallback over just hugging
+  directly, so this always does instead
+
 **Hugging an arrow function's concise body:**
 
 ```js

package/dist/index.js

@@ -67,7 +67,15 @@ const estreePrinter = estree.printers.estree;
 function hasComment(node) {
     return Boolean(node?.comments && node.comments.length > 0);
 }
-function isHuggableFunction(node) {
+/**
+ * The terminal thing worth hugging at the bottom of a chain of wrapping
+ * calls: a function (the common `catchAsync(cb)` case), or a plain
+ * object/array literal directly (e.g. `firstValueFrom(client.getX({ ... }))`
+ * — the object isn't itself wrapped in a function, but it's exactly what
+ * Prettier would hug directly if it were the argument of a plain, unwrapped
+ * call).
+ */
+function isHuggableLiteral(node) {
     if (!node) {
         return false;
     }
@@ -80,7 +88,7 @@ function isHuggableFunction(node) {
             body?.type === "ObjectExpression" ||
             body?.type === "ArrayExpression");
     }
-    return false;
+    return node.type === "ObjectExpression" || node.type === "ArrayExpression";
 }
 /**
  * A short, unbreakable-looking companion argument — the kind lodash-style
@@ -118,7 +126,7 @@ function couldExpandArg(node, depth = 0) {
     if (!node || depth > 4) {
         return false;
     }
-    if (isHuggableFunction(node)) {
+    if (isHuggableLiteral(node)) {
         return true;
     }
     if (node.type === "CallExpression" &&
@@ -194,6 +202,35 @@ 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.
+ */
+/**
+ * Prettier's own member/call-chain printer makes its "should I break at the
+ * dots" decision using context (the surrounding call, the real column) this
+ * plugin's manually-reconstructed docs don't provide when they print a
+ * callee in isolation via `print("callee")` — which can make a callee that
+ * vanilla Prettier would never break on its own (see the linked issue)
+ * break at its dots anyway once disconnected from that context. Rendering
+ * it standalone at an effectively unlimited width and using the resulting
+ * plain text instead sidesteps the whole problem: nothing left to make that
+ * decision differently. If something still forces a real break even at
+ * unlimited width (a comment, most likely), this returns `undefined` and
+ * the caller should bail rather than risk it.
+ */
+function renderFlatOrUndefined(doc, options) {
+    const { formatted } = doc_1.printer.printDocToString(doc, {
+        ...options,
+        printWidth: Number.MAX_SAFE_INTEGER,
+    });
+    return formatted.includes("\n") ? undefined : formatted;
+}
 /**
  * Prettier's own doc printer doesn't reliably re-check `printWidth` for
  * plain content that comes *after* a forced break inside a conditionalGroup
@@ -312,6 +349,13 @@ function tryPreserveMultilineList(path, options, print, kind) {
         // other hugging attempts, or Prettier's own default, decide.
         return undefined;
     }
+    if (kind === "call") {
+        const flatPrefix = renderFlatOrUndefined(prefixDoc, options);
+        if (flatPrefix === undefined) {
+            return undefined;
+        }
+        prefixDoc = flatPrefix;
+    }
     const printedItems = printItems();
     const listDoc = [
         openChar,
@@ -325,6 +369,49 @@ function tryPreserveMultilineList(path, options, print, kind) {
     ];
     return [breakParent, prefixDoc, listDoc, suffixDoc];
 }
+/**
+ * A call with exactly one argument that's directly an object or array
+ * literal — `getX({ ... })` — is already hugged reliably by Prettier on its
+ * own, *in isolation*. But Prettier's own "hug the sole argument" mechanism
+ * is still gated on whether the opening line fits at the real column, and
+ * gives up (breaking the call's own parens too) when it doesn't — which
+ * becomes very possible once this plugin has already fused several outer
+ * layers together (e.g. `firstValueFrom(client.getX({ ... }))`, once
+ * `firstValueFrom(...)` hugs, pushes `getX(`'s real column much deeper).
+ * There's essentially never a readability win to giving up like that
+ * instead of just hugging directly, so this always does — but, like the
+ * plugin's other hugging features, only once the argument actually needs
+ * multi-line printing; a short object/array that already fits is left
+ * alone.
+ */
+function tryHugSoleLiteralArg(path, options, print) {
+    const { node } = path;
+    if (node.type !== "CallExpression" ||
+        node.optional ||
+        node.typeArguments ||
+        node.typeParameters ||
+        !node.callee ||
+        !isSimpleCallee(node.callee)) {
+        return undefined;
+    }
+    const args = node.arguments ?? [];
+    const [only] = args;
+    if (args.length !== 1 ||
+        !only ||
+        hasComment(only) ||
+        (only.type !== "ObjectExpression" && only.type !== "ArrayExpression")) {
+        return undefined;
+    }
+    const argDoc = path.map(print, "arguments")[0];
+    if (argDoc === undefined || !wouldBreakStandalone(argDoc, options)) {
+        return undefined;
+    }
+    const calleeDoc = renderFlatOrUndefined(print("callee"), options);
+    if (calleeDoc === undefined) {
+        return undefined;
+    }
+    return [breakParent, calleeDoc, "(", argDoc, ")"];
+}
 function tryHugWrappedCallback(path, options, print) {
     const { node } = path;
     if (node.type !== "CallExpression" || node.optional) {
@@ -360,12 +447,16 @@ function tryHugWrappedCallback(path, options, print) {
         !wouldBreakStandalone(expandDoc, options)) {
         return undefined;
     }
+    const calleeDoc = renderFlatOrUndefined(print("callee"), options);
+    if (calleeDoc === undefined) {
+        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"),
+        calleeDoc,
         "(",
         ...beforeWithCommas,
         group(expandDoc, { shouldBreak: true }),
@@ -580,6 +671,7 @@ const plugin = {
                     tryPreserveMultilineList(path, options, print, "array") ??
                     tryPreserveMultilineList(path, options, print, "params") ??
                     tryHugWrappedCallback(path, options, print) ??
+                    tryHugSoleLiteralArg(path, options, print) ??
                     tryHugArrowBody(path, options, print) ??
                     tryHugChainArgument(path, options, print);
                 return hugged === undefined

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-hug-call-arguments",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "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",
@@ -50,7 +50,7 @@
     "prettier": ">=3.0.0"
   },
   "devDependencies": {
-    "@types/node": "^26.3.0",
+    "@types/node": "^26.4.0",
     "prettier": "^3.9.6",
     "typescript": "^7.0.2"
   }