prettier-plugin-hug-call-arguments 0.1.8 → 0.1.10

package/README.md

@@ -120,8 +120,47 @@ db.updateTable("User").set({
 ## How it works
 
 This plugin wraps Prettier's built-in `estree` printer and only overrides the
-`print` step for `CallExpression` and `ArrowFunctionExpression` nodes that
-match one of a few narrow, specific shapes.
+`print` step for `CallExpression`, `ArrayExpression`, and
+`ArrowFunctionExpression` nodes that match one of a few narrow, specific
+shapes.
+
+**Preserving a layout you already chose:**
+
+```js
+// input
+foo(
+  1,
+  2,
+);
+
+// with this plugin — kept exactly as written
+foo(
+  1,
+  2,
+);
+
+// bar(1, 2, 3) stays on one line — nothing to preserve, so it's printed
+// the normal, printWidth-aware way
+```
+
+Prettier already does this for object literals by default (`objectWrap:
+"preserve"`): write `{` with a newline before the first property and it
+stays multi-line, even if it would fit on one line. This plugin extends that
+same "respect how the author wrote it" behavior to call arguments, array
+elements, and arrow function parameter lists, which Prettier doesn't
+normally preserve — those always auto-collapse to fit `printWidth`
+regardless of the original formatting.
+
+- applies once there are at least two items with a newline right after the
+  opening `(`/`[` and before the first one — a single item has no "one per
+  line" layout to preserve, so that's left to this plugin's other hugging
+  behavior, or Prettier's own
+- takes priority over every other feature below: a layout you explicitly
+  chose is never fought by this plugin's own hugging heuristics
+- bails on comments anywhere in the list, a sparse array, TS type
+  arguments/parameters, or (for parameters) anything but a plain arrow
+  function — a `function` expression/declaration has a name and block body
+  to reproduce too, which is more than this narrow check takes on
 
 **Hugging a call-wrapped callback:**
 
@@ -141,6 +180,28 @@ match one of a few narrow, specific shapes.
 - 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.d.ts

@@ -28,6 +28,7 @@ interface ESNode {
     async?: boolean;
     returnType?: unknown;
     predicate?: unknown;
+    elements?: ESNode[];
 }
 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, indent, line, softline, join, ifBreak, breakParent } = doc_1.builders;
+const { group, indent, line, softline, hardline, 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.
@@ -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
@@ -209,6 +246,172 @@ function fitsWhenFlattened(doc, options) {
         .split("\n")
         .every((line) => line.length <= options.printWidth);
 }
+function getTrailingComma(options, kind) {
+    if (options.trailingComma === "all") {
+        return ",";
+    }
+    if (options.trailingComma === "es5" && kind === "array") {
+        return ",";
+    }
+    return "";
+}
+/**
+ * Prettier already preserves this for object literals by default
+ * (`objectWrap: "preserve"`): write `{` with a newline before the first
+ * property and it stays multi-line, even if it would otherwise fit on one
+ * line. Prettier doesn't extend that courtesy to call arguments, array
+ * elements, or parameter lists — those always auto-collapse to fit
+ * `printWidth` regardless of how they were originally written. This
+ * reproduces the same "respect how the author wrote it" behavior for those
+ * three, so the plugin's own hugging heuristics never fight a layout the
+ * developer explicitly chose by hand.
+ *
+ * Only applies once there are at least two items — with a single item,
+ * there's no "one per line" layout to preserve, and that case is already
+ * handled by this plugin's other hugging behavior (or Prettier's own).
+ * Bails on anything that would make correctly locating the opening bracket
+ * or reproducing the layout unsafe: comments anywhere in the list, a sparse
+ * array, or (for calls) TS type arguments.
+ */
+function tryPreserveMultilineList(path, options, print, kind) {
+    const { node } = path;
+    let items;
+    let openChar;
+    let closeChar;
+    let searchFrom;
+    let prefixDoc = "";
+    let suffixDoc = "";
+    let printItems;
+    if (kind === "call") {
+        if (node.type !== "CallExpression" ||
+            node.optional ||
+            node.typeArguments ||
+            node.typeParameters ||
+            !node.callee ||
+            !isSimpleCallee(node.callee) ||
+            // Let chain-flattening handle the outermost call of a chain instead —
+            // this only steps in for a plain, non-chained call.
+            (node.callee.type === "MemberExpression" &&
+                node.callee.object?.type === "CallExpression")) {
+            return undefined;
+        }
+        items = node.arguments ?? [];
+        openChar = "(";
+        closeChar = ")";
+        searchFrom = node.callee.end;
+        prefixDoc = print("callee");
+        printItems = () => path.map(print, "arguments");
+    }
+    else if (kind === "array") {
+        if (node.type !== "ArrayExpression") {
+            return undefined;
+        }
+        items = node.elements ?? [];
+        openChar = "[";
+        closeChar = "]";
+        searchFrom = node.start;
+        printItems = () => path.map(print, "elements");
+    }
+    else {
+        // Arrow functions only — a plain `function` expression/declaration also
+        // has a name and a block body to reproduce, which is more than this
+        // narrow check is worth taking on.
+        if (node.type !== "ArrowFunctionExpression" ||
+            node.typeParameters ||
+            node.returnType ||
+            node.predicate ||
+            !node.body ||
+            hasComment(node.body)) {
+            return undefined;
+        }
+        items = node.params ?? [];
+        openChar = "(";
+        closeChar = ")";
+        searchFrom = node.start;
+        prefixDoc = node.async ? "async " : "";
+        suffixDoc = [" => ", print("body")];
+        printItems = () => path.map(print, "params");
+    }
+    if (items.length < 2 ||
+        hasComment(node) ||
+        items.some((item) => !item || hasComment(item)) ||
+        searchFrom === undefined) {
+        return undefined;
+    }
+    const openIndex = options.originalText.indexOf(openChar, searchFrom);
+    const firstStart = items[0]?.start;
+    if (openIndex === -1 || firstStart === undefined) {
+        return undefined;
+    }
+    const between = options.originalText.slice(openIndex + 1, firstStart);
+    if (!/\n/.test(between)) {
+        // Not originally multi-line — nothing to preserve; let this plugin's
+        // 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,
+        indent([
+            hardline,
+            join([",", hardline], printedItems),
+            getTrailingComma(options, kind),
+        ]),
+        hardline,
+        closeChar,
+    ];
+    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) {
@@ -244,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 }),
@@ -458,7 +665,13 @@ const plugin = {
         estree: {
             ...estreePrinter,
             print(path, options, print, args) {
-                const hugged = tryHugWrappedCallback(path, options, print) ??
+                // Preserving a layout the developer explicitly chose by hand takes
+                // priority over this plugin's own hugging heuristics.
+                const hugged = tryPreserveMultilineList(path, options, print, "call") ??
+                    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.8",
+  "version": "0.1.10",
   "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",