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

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,44 @@ app.delete("/campgrounds/:id", catchAsync(async (req, res) => {
 }));
 ```
 
+It also flattens short method chains where exactly one call's argument needs
+to break, 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 +102,17 @@ 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-computed, non-optional `.name(...)` call down to
+  a simple base (an identifier, `this`, or a non-computed member chain)
+- exactly one link's arguments need to break — zero or more than one falls
+  back to Prettier's normal chain layout
+- the flattened result is rendered and measured against `printWidth`; if any
+  line would overflow, it falls back to Prettier's normal chain layout too
+
+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

@@ -181,12 +181,127 @@ function tryHugWrappedCallback(path, options, print) {
         ]),
     ];
 }
+const MAX_CHAIN_LINKS = 6;
+/**
+ * Walks down `node.callee.object` as long as it's a plain, non-computed,
+ * non-optional `.name(...)` call, printing each link's arguments along the
+ * way. Returns `undefined` the moment anything doesn't match that shape
+ * (computed access, optional chaining, generics, comments, spread callee,
+ * ...), so the caller can safely fall back to Prettier's own chain printer.
+ */
+function collectChainLinks(path, print, 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.computed ||
+        callee.optional ||
+        hasComment(callee)) {
+        return undefined;
+    }
+    const { property } = callee;
+    if (!property || property.type !== "Identifier" || hasComment(property)) {
+        return undefined;
+    }
+    const link = {
+        name: property.name ?? "",
+        argsDocs: path.map(print, "arguments"),
+    };
+    const { object } = callee;
+    if (!object || hasComment(object)) {
+        return undefined;
+    }
+    if (object.type === "CallExpression") {
+        const inner = path.call((innerPath) => collectChainLinks(innerPath, print, 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 };
+}
+/**
+ * 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 flat chain on its own, render
+ * the candidate standalone and check every line ourselves.
+ */
+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 one argument (here
+ * the object passed to `.set`) doesn't fit. When exactly one link in the
+ * chain needs to break and the rest are short, this keeps the chain flat and
+ * only lets that one argument expand — falling back to Prettier's own
+ * chain layout (via `conditionalGroup`) if the flat version doesn't fit.
+ */
+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.computed ||
+        !node.callee.object ||
+        node.callee.object.type !== "CallExpression") {
+        return undefined;
+    }
+    const collected = collectChainLinks(path, print, 0);
+    if (!collected || collected.links.length < 2) {
+        return undefined;
+    }
+    const { links, baseDoc } = collected;
+    const breakingLinks = links.filter((link) => link.argsDocs.some((doc) => willBreak(doc)));
+    if (breakingLinks.length !== 1) {
+        return undefined;
+    }
+    const flatDoc = [
+        baseDoc,
+        ...links.map((link) => {
+            const joinedArgs = link.argsDocs.flatMap((doc, index) => index === 0 ? [doc] : [", ", doc]);
+            return [".", link.name, "(", ...joinedArgs, ")"];
+        }),
+    ];
+    if (!fitsWhenFlattened(flatDoc, options)) {
+        return undefined;
+    }
+    return [breakParent, 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.1",
   "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",