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

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,31 @@ 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 an arrow function's concise body:**
+
+```js
+// input
+const f = (data) =>
+  pgBoss.then((boss) => {
+    return boss.send(jobName, data);
+  });
+
+// with this plugin
+const f = (data) => pgBoss.then((boss) => {
+  return boss.send(jobName, data);
+});
+```
+
+- the arrow has a concise (non-block) body, no type parameters, return type,
+  or predicate, and default `arrowParens`
+- the body is a `CallExpression` that needs multi-line printing (Prettier
+  already hugs directly after `=>` for other body types — objects, arrays,
+  JSX, template literals — so there's no gap to fix there)
+- the resulting line fits `printWidth`; otherwise this falls back to
+  Prettier's default (a hardline after `=>`, body indented on its own line).
+  The arrow's own parameter list can still break onto its own line first the
+  normal way — only the `=> body` boundary is affected
+
 **Flattening a method chain:**
 
 - every link is a plain, non-optional `.name(...)` or `[expr](...)` call down

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.
@@ -209,6 +209,122 @@ 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;
+    }
+    const printedItems = printItems();
+    const listDoc = [
+        openChar,
+        indent([
+            hardline,
+            join([",", hardline], printedItems),
+            getTrailingComma(options, kind),
+        ]),
+        hardline,
+        closeChar,
+    ];
+    return [breakParent, prefixDoc, listDoc, suffixDoc];
+}
 function tryHugWrappedCallback(path, options, print) {
     const { node } = path;
     if (node.type !== "CallExpression" || node.optional) {
@@ -458,7 +574,12 @@ 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) ??
                     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.7",
+  "version": "0.1.9",
   "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",