prettier-plugin-hug-call-arguments 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 soso
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# prettier-plugin-hug-call-arguments
+
+Fixes [prettier/prettier#11080](https://github.com/prettier/prettier/issues/11080).
+
+Prettier hugs the last argument of a call when it's a function/object/array
+literal:
+
+```js
+app.get("/x", (req, res) => {
+  res.send("ok");
+});
+```
+
+...but not when that literal is wrapped in another call, which is a very
+common pattern for middleware wrappers (Express `catchAsync`, error
+boundaries, decorators-as-functions, etc.):
+
+```js
+// input
+app.delete('/campgrounds/:id', catchAsync(async (req, res) => {
+  const { id } = req.params;
+  await Campground.findByIdAndDelete(id);
+  res.redirect('/campgrounds');
+}));
+
+// vanilla Prettier output
+app.delete(
+  "/campgrounds/:id",
+  catchAsync(async (req, res) => {
+    const { id } = req.params;
+    await Campground.findByIdAndDelete(id);
+    res.redirect("/campgrounds");
+  }),
+);
+
+// with this plugin
+app.delete("/campgrounds/:id", catchAsync(async (req, res) => {
+  const { id } = req.params;
+  await Campground.findByIdAndDelete(id);
+  res.redirect("/campgrounds");
+}));
+```
+
+## How it works
+
+This plugin wraps Prettier's built-in `estree` printer and only overrides the
+`print` step for `CallExpression` nodes that match a narrow, specific shape:
+
+- 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
+- there's no blank line between arguments, no comments on the relevant
+  nodes, and no TS type arguments
+
+Every other node, and every `CallExpression` that doesn't match that shape,
+is delegated unchanged to Prettier's original printer.
+
+## Usage
+
+```sh
+npm install --save-dev prettier-plugin-hug-call-arguments
+```
+
+`.prettierrc`:
+
+```json
+{
+  "plugins": ["prettier-plugin-hug-call-arguments"]
+}
+```
+
+## Development
+
+```sh
+npm install
+npm run build
+npm test
+```

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "prettier";
+/** Minimal structural view of the ESTree/Babel nodes this plugin touches. */
+interface ESNode {
+    type: string;
+    start?: number;
+    end?: number;
+    comments?: unknown[];
+    optional?: boolean;
+    computed?: boolean;
+    typeArguments?: unknown;
+    typeParameters?: unknown;
+    callee?: ESNode;
+    object?: ESNode;
+    arguments?: ESNode[];
+    body?: ESNode;
+}
+declare const plugin: Plugin<ESNode>;
+export = plugin;

package/dist/index.js

@@ -0,0 +1,197 @@
+"use strict";
+// Fixes https://github.com/prettier/prettier/issues/11080
+//
+// Prettier "hugs" the last argument of a call and keeps the earlier
+// arguments on the opening line when the last argument is itself a
+// function/object/array literal, e.g.:
+//
+//   app.get("/x", (req, res) => {
+//     ...
+//   });
+//
+// But it refuses to do that when the last argument is a *call* that wraps
+// such a literal, e.g. Express-style middleware wrappers:
+//
+//   app.delete("/campgrounds/:id", catchAsync(async (req, res) => {
+//     ...
+//   }));
+//
+// In that case Prettier falls back to breaking every argument onto its own
+// line. This plugin extends the "can this be hugged" check to look through
+// one or more wrapping calls, and reproduces Prettier's own hugging layout
+// for that case. Every other case is delegated to the original estree
+// printer, untouched.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const doc_1 = require("prettier/doc");
+// `prettier/plugins/estree` ships CommonJS + ESM builds; the CJS build is
+// 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, join, 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.
+const estreePrinter = estree.printers.estree;
+function hasComment(node) {
+    return Boolean(node?.comments && node.comments.length > 0);
+}
+function isHuggableFunction(node) {
+    if (!node) {
+        return false;
+    }
+    if (node.type === "FunctionExpression") {
+        return true;
+    }
+    if (node.type === "ArrowFunctionExpression") {
+        const body = node.body;
+        return (body?.type === "BlockStatement" ||
+            body?.type === "ObjectExpression" ||
+            body?.type === "ArrayExpression");
+    }
+    return false;
+}
+/**
+ * Like Prettier's internal `couldExpandArg`, but also looks through calls
+ * that merely wrap a huggable function, e.g. `catchAsync(async () => {})`.
+ */
+function couldExpandArg(node, depth = 0) {
+    if (!node || depth > 4) {
+        return false;
+    }
+    if (isHuggableFunction(node)) {
+        return true;
+    }
+    if (node.type === "CallExpression" &&
+        !node.optional &&
+        !hasComment(node) &&
+        node.arguments &&
+        node.arguments.length > 0 &&
+        !node.typeArguments &&
+        !node.typeParameters) {
+        return couldExpandArg(node.arguments.at(-1), depth + 1);
+    }
+    return false;
+}
+/**
+ * Only intervene for plain-looking callees (`foo(...)`, `a.b.c(...)`) so we
+ * never fight Prettier's member/call-chain printing (`a().b().c(cb)`).
+ */
+function isSimpleCallee(callee) {
+    if (callee.type === "Identifier" ||
+        callee.type === "ThisExpression" ||
+        callee.type === "Super") {
+        return true;
+    }
+    if (callee.type === "MemberExpression" && !callee.computed && callee.object) {
+        return isSimpleCallee(callee.object);
+    }
+    return false;
+}
+function hasBlankLineBetween(originalText, start, end) {
+    return /\n[^\S\n]*\n/.test(originalText.slice(start, end));
+}
+function tryHugWrappedCallback(path, options, print) {
+    const { node } = path;
+    if (node.type !== "CallExpression" || node.optional) {
+        return undefined;
+    }
+    if (node.typeArguments || node.typeParameters) {
+        return undefined;
+    }
+    const args = node.arguments ?? [];
+    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)) {
+        return undefined;
+    }
+    for (let i = 0; i < args.length - 1; i++) {
+        const current = args[i];
+        const next = args[i + 1];
+        if (current?.end !== undefined &&
+            next?.start !== undefined &&
+            hasBlankLineBetween(options.originalText, current.end, next.start)) {
+            return undefined;
+        }
+    }
+    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
+    // wouldn't break anyway, Prettier's default output is already fine.
+    if (lastDoc === undefined ||
+        headDocs.some((doc) => willBreak(doc)) ||
+        !willBreak(lastDoc)) {
+        return undefined;
+    }
+    const headWithCommas = headDocs.flatMap((doc) => [doc, ", "]);
+    const trailingComma = options.trailingComma === "all" ? "," : "";
+    const allArgsBrokenOut = () => group([
+        "(",
+        indent([hardline, join([",", hardline], printedArgs)]),
+        trailingComma,
+        hardline,
+        ")",
+    ], { shouldBreak: true });
+    return [
+        breakParent,
+        print("callee"),
+        conditionalGroup([
+            ["(", ...headWithCommas, group(lastDoc, { shouldBreak: true }), ")"],
+            allArgsBrokenOut(),
+        ]),
+    ];
+}
+const plugin = {
+    printers: {
+        estree: {
+            ...estreePrinter,
+            print(path, options, print, args) {
+                const hugged = tryHugWrappedCallback(path, options, print);
+                return hugged === undefined
+                    ? estreePrinter.print(path, options, print, args)
+                    : hugged;
+            },
+        },
+    },
+};
+module.exports = plugin;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "prettier-plugin-hug-call-arguments",
+  "version": "0.1.0",
+  "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",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist dist-test",
+    "build": "npm run clean && tsc --project tsconfig.json",
+    "test": "npm run build && tsc --project tsconfig.test.json && node --test ./dist-test/*.js && rm -rf ./dist-test",
+    "prepublishOnly": "npm run test"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Generalsimus/prettier-plugin-hug-call-arguments.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Generalsimus/prettier-plugin-hug-call-arguments/issues"
+  },
+  "homepage": "https://github.com/Generalsimus/prettier-plugin-hug-call-arguments#readme",
+  "keywords": [
+    "prettier",
+    "prettier-plugin",
+    "formatter",
+    "code-style",
+    "call-arguments",
+    "callback",
+    "typescript"
+  ],
+  "peerDependencies": {
+    "prettier": ">=3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.3.0",
+    "prettier": "^3.9.6",
+    "typescript": "^7.0.2"
+  }
+}