prettier-plugin-hug-call-arguments 0.1.0 → 0.1.2

package/README.md

@@ -1,5 +1,19 @@
 # prettier-plugin-hug-call-arguments
 
+[![license][license-src]][license-href]
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![CI][ci-src]][ci-href]
+
+[license-src]: https://img.shields.io/badge/license-MIT-brightgreen?&style=flat-square
+[license-href]: https://github.com/Generalsimus/prettier-plugin-hug-call-arguments/blob/main/LICENSE
+[npm-version-src]: https://img.shields.io/npm/v/prettier-plugin-hug-call-arguments?&style=flat-square&logo=npm&logoColor=white&color=CB3837
+[npm-version-href]: https://www.npmjs.com/package/prettier-plugin-hug-call-arguments
+[npm-downloads-src]: https://img.shields.io/npm/dt/prettier-plugin-hug-call-arguments?&style=flat-square&logo=npm&logoColor=white&color=CB3837
+[npm-downloads-href]: https://www.npmjs.com/package/prettier-plugin-hug-call-arguments
+[ci-src]: https://img.shields.io/github/actions/workflow/status/Generalsimus/prettier-plugin-hug-call-arguments/test.yml?branch=main&&style=flat-square
+[ci-href]: https://github.com/Generalsimus/prettier-plugin-hug-call-arguments/actions/workflows/test.yml
+
 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
@@ -41,10 +55,43 @@ app.delete("/campgrounds/:id", catchAsync(async (req, res) => {
 }));
 ```
 
+It also flattens method chains instead of breaking every `.method()` onto its
+own line — a common look with query builders:
+
+```js
+// input
+db.updateTable('User').set({
+  isDeleted: true,
+  profilePicture: null,
+  username: null,
+}).where('id', '=', user.id).execute();
+
+// vanilla Prettier output
+db
+  .updateTable("User")
+  .set({
+    isDeleted: true,
+    profilePicture: null,
+    username: null,
+  })
+  .where("id", "=", user.id)
+  .execute();
+
+// with this plugin
+db.updateTable("User").set({
+  isDeleted: true,
+  profilePicture: null,
+  username: null,
+}).where("id", "=", user.id).execute();
+```
+
 ## 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:
+`print` step for `CallExpression` nodes that match one of two narrow, specific
+shapes.
+
+**Hugging a call-wrapped callback:**
 
 - the callee is a plain identifier or non-computed member chain (`foo`,
   `a.b.c`) — chained calls (`a().b()`) are left untouched
@@ -54,8 +101,23 @@ This plugin wraps Prettier's built-in `estree` printer and only overrides the
 - 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.
+**Flattening a method chain:**
+
+- every link is a plain, non-optional `.name(...)` or `[expr](...)` call down
+  to a simple base (an identifier, `this`, or a non-computed member chain)
+- each link's own arguments are printed exactly as Prettier would print them
+  standalone — a single object/array/function argument hugs the parens, a
+  multi-argument list breaks onto its own lines only if it doesn't fit — so
+  any number of links can break independently, correctly, with no special
+  casing needed
+- the whole flattened candidate is still rendered and measured against
+  `printWidth` as a final check (catching the one thing per-link breaking
+  can't: many short, individually-fitting links whose *combined* length
+  still overflows); if any line would overflow, it falls back to Prettier's
+  normal chain layout
+
+Every other node, and every `CallExpression` that doesn't match one of these
+shapes, is delegated unchanged to Prettier's original printer.
 
 ## Usage
 

package/dist/index.d.ts

@@ -1,5 +1,14 @@
 import type { Plugin } from "prettier";
-/** Minimal structural view of the ESTree/Babel nodes this plugin touches. */
+/**
+ * Minimal structural view of the ESTree/Babel nodes this plugin touches.
+ *
+ * `callee` and `object` are declared as required so `AstPath#call` can chain
+ * through them (`path.call(fn, "callee", "object")`) without the type
+ * collapsing to `never` — see https://github.com/microsoft/TypeScript's
+ * handling of `keyof (T | undefined)`. Every real read of these fields is
+ * still guarded by a runtime truthiness check, since plenty of node types
+ * don't actually have them.
+ */
 interface ESNode {
     type: string;
     start?: number;
@@ -9,8 +18,10 @@ interface ESNode {
     computed?: boolean;
     typeArguments?: unknown;
     typeParameters?: unknown;
-    callee?: ESNode;
-    object?: ESNode;
+    callee: ESNode;
+    object: ESNode;
+    property: ESNode;
+    name?: string;
     arguments?: ESNode[];
     body?: ESNode;
 }

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, conditionalGroup, indent, hardline, join, breakParent } = doc_1.builders;
+const { group, conditionalGroup, indent, hardline, line, softline, 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.
@@ -122,6 +122,23 @@ function isSimpleCallee(callee) {
 function hasBlankLineBetween(originalText, start, end) {
     return /\n[^\S\n]*\n/.test(originalText.slice(start, end));
 }
+/**
+ * `willBreak` only sees *forced* breaks (a hardline, or a group Prettier
+ * already marked `shouldBreak: true` — e.g. an object literal whose first
+ * property was already on its own line in the source, via `objectWrap:
+ * "preserve"`). A conditional break — an object written on one line that's
+ * simply too long to fit — has neither, so `willBreak` misses it. Render the
+ * doc standalone and check whether it needed more than one line instead.
+ * This only decides *how many* links look like they'll break for our own
+ * "exactly one" heuristic; the actual safety net against overflow is
+ * `fitsWhenFlattened`, which measures the real assembled doc.
+ */
+function wouldBreakStandalone(doc, options) {
+    if (willBreak(doc)) {
+        return true;
+    }
+    return doc_1.printer.printDocToString(doc, options).formatted.includes("\n");
+}
 function tryHugWrappedCallback(path, options, print) {
     const { node } = path;
     if (node.type !== "CallExpression" || node.optional) {
@@ -159,8 +176,8 @@ function tryHugWrappedCallback(path, options, print) {
     // 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)) {
+        headDocs.some((doc) => wouldBreakStandalone(doc, options)) ||
+        !wouldBreakStandalone(lastDoc, options)) {
         return undefined;
     }
     const headWithCommas = headDocs.flatMap((doc) => [doc, ", "]);
@@ -181,12 +198,157 @@ function tryHugWrappedCallback(path, options, print) {
         ]),
     ];
 }
+const MAX_CHAIN_LINKS = 6;
+/**
+ * Builds the `(...)` doc for one link's argument list the same way a plain,
+ * standalone call would print it: a single argument is hugged directly
+ * against the parens (so an object/array still expands in place, e.g.
+ * `.set({ ... })`, not indented as its own nested line); more than one
+ * argument gets Prettier's normal "fits on one line, else one per line"
+ * group. Either way the break decision is left to Prettier's regular,
+ * width-aware group mechanics — not something this plugin pre-computes.
+ */
+function buildArgsDoc(argsDocs, trailingComma) {
+    if (argsDocs.length === 0) {
+        return "()";
+    }
+    const [only] = argsDocs;
+    if (argsDocs.length === 1 && only !== undefined) {
+        return ["(", only, ")"];
+    }
+    return group([
+        "(",
+        indent([softline, join([",", line], argsDocs)]),
+        ifBreak(trailingComma),
+        softline,
+        ")",
+    ]);
+}
+/**
+ * Walks down `node.callee.object` as long as it's a plain, non-optional
+ * `.name(...)` or `[expr](...)` call, printing each link's property access
+ * and arguments along the way. Returns `undefined` the moment anything
+ * doesn't match that shape (optional chaining, generics, comments, spread
+ * callee, ...), so the caller can safely fall back to Prettier's own chain
+ * printer.
+ */
+function collectChainLinks(path, print, options, depth) {
+    if (depth > MAX_CHAIN_LINKS) {
+        return undefined;
+    }
+    const { node } = path;
+    if (node.type !== "CallExpression" ||
+        node.optional ||
+        node.typeArguments ||
+        node.typeParameters ||
+        hasComment(node)) {
+        return undefined;
+    }
+    const { callee } = node;
+    if (!callee ||
+        callee.type !== "MemberExpression" ||
+        callee.optional ||
+        hasComment(callee)) {
+        return undefined;
+    }
+    const { property } = callee;
+    if (!property || hasComment(property)) {
+        return undefined;
+    }
+    let accessDoc;
+    if (callee.computed) {
+        accessDoc = ["[", path.call(print, "callee", "property"), "]"];
+    }
+    else if (property.type === "Identifier") {
+        accessDoc = [".", property.name ?? ""];
+    }
+    else {
+        return undefined;
+    }
+    const trailingComma = options.trailingComma === "all" ? "," : "";
+    const link = {
+        accessDoc,
+        argsDoc: buildArgsDoc(path.map(print, "arguments"), trailingComma),
+    };
+    const { object } = callee;
+    if (!object || hasComment(object)) {
+        return undefined;
+    }
+    if (object.type === "CallExpression") {
+        const inner = path.call((innerPath) => collectChainLinks(innerPath, print, options, depth + 1), "callee", "object");
+        return inner === undefined
+            ? undefined
+            : { links: [...inner.links, link], baseDoc: inner.baseDoc };
+    }
+    if (!isSimpleCallee(object)) {
+        return undefined;
+    }
+    const baseDoc = path.call(print, "callee", "object");
+    return { links: [link], baseDoc };
+}
+/**
+ * Each link's own argument list already breaks correctly on its own — via
+ * Prettier's normal, width-aware group mechanics — because there's no group
+ * wrapping the whole chain forcing anything. The one thing that mechanism
+ * can't see is a chain of many short, individually-non-breaking links whose
+ * *combined* length still overflows `printWidth` (nothing internal to break
+ * on). So render the assembled candidate standalone and check every line
+ * before committing to it, falling back to Prettier's own chain layout if
+ * it doesn't fit.
+ */
+function fitsWhenFlattened(doc, options) {
+    const { formatted } = doc_1.printer.printDocToString(doc, options);
+    return formatted
+        .split("\n")
+        .every((line) => line.length <= options.printWidth);
+}
+/**
+ * Handles method chains like `db.updateTable("User").set({ ... }).where(
+ * "id", "=", user.id).execute()`, where Prettier's default chain printer
+ * breaks every `.method()` onto its own line as soon as any argument
+ * doesn't fit. This instead keeps the whole chain flat — `.foo(...).bar(
+ * ...).baz(...)` — and lets each link's own arguments break independently
+ * if they need to, falling back to Prettier's normal chain layout only if
+ * the flattened result doesn't fit the shape this plugin handles, or would
+ * overflow `printWidth`.
+ */
+function tryHugChainArgument(path, options, print) {
+    const { node } = path;
+    if (node.type !== "CallExpression" || node.optional) {
+        return undefined;
+    }
+    // Only handle the outermost call of a chain — if this call is itself
+    // being member-accessed further, let that outer node make the decision.
+    if (path.parent?.type === "MemberExpression") {
+        return undefined;
+    }
+    if (!node.callee ||
+        node.callee.type !== "MemberExpression" ||
+        !node.callee.object ||
+        node.callee.object.type !== "CallExpression") {
+        return undefined;
+    }
+    const collected = collectChainLinks(path, print, options, 0);
+    if (!collected || collected.links.length < 2) {
+        return undefined;
+    }
+    const { links, baseDoc } = collected;
+    const flatDoc = [
+        baseDoc,
+        ...links.map((link) => [link.accessDoc, link.argsDoc]),
+    ];
+    if (!fitsWhenFlattened(flatDoc, options)) {
+        return undefined;
+    }
+    return willBreak(flatDoc) ? [breakParent, flatDoc] : flatDoc;
+}
 const plugin = {
     printers: {
         estree: {
             ...estreePrinter,
             print(path, options, print, args) {
-                const hugged = tryHugWrappedCallback(path, options, print);
+                const hugged = tryHugWrappedCallback(path, options, print) ??
+                    tryHugChainArgument(path, options, print);
                 return hugged === undefined
                     ? estreePrinter.print(path, options, print, args)
                     : hugged;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier-plugin-hug-call-arguments",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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",