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

package/README.md

@@ -120,8 +120,8 @@ 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:**
 
@@ -141,6 +141,31 @@ 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

@@ -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

@@ -269,6 +269,62 @@ function tryHugWrappedCallback(path, options, print) {
     }
     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 trailingComma = options.trailingComma === "all" ? "," : "";
+    const paramsDoc = group([
+        "(",
+        indent([softline, join([",", line], path.map(print, "params"))]),
+        ifBreak(trailingComma),
+        softline,
+        ")",
+    ]);
+    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;
 /**
  * Builds the `(...)` doc for one link's argument list the same way a plain,
@@ -403,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.6",
+  "version": "0.1.8",
   "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",