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

package/README.md

@@ -55,9 +55,8 @@ 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:
+It also flattens method chains instead of breaking every `.method()` onto its
+own line — a common look with query builders:
 
 ```js
 // input
@@ -104,12 +103,18 @@ shapes.
 
 **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 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.

package/dist/index.d.ts

@@ -20,7 +20,7 @@ interface ESNode {
     typeParameters?: unknown;
     callee: ESNode;
     object: ESNode;
-    property?: 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, ", "]);
@@ -183,13 +200,39 @@ 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.
+ * 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 collectChainLinks(path, print, depth) {
+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;
     }
@@ -204,25 +247,35 @@ function collectChainLinks(path, print, depth) {
     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)) {
+    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 = {
-        name: property.name ?? "",
-        argsDocs: path.map(print, "arguments"),
+        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, depth + 1), "callee", "object");
+        const inner = path.call((innerPath) => collectChainLinks(innerPath, print, options, depth + 1), "callee", "object");
         return inner === undefined
             ? undefined
             : { links: [...inner.links, link], baseDoc: inner.baseDoc };
@@ -234,13 +287,14 @@ function collectChainLinks(path, print, depth) {
     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.
+ * 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);
@@ -251,11 +305,12 @@ function fitsWhenFlattened(doc, options) {
 /**
  * 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.
+ * 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;
@@ -269,31 +324,23 @@ function tryHugChainArgument(path, options, print) {
     }
     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);
+    const collected = collectChainLinks(path, print, options, 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, ")"];
-        }),
+        ...links.map((link) => [link.accessDoc, link.argsDoc]),
     ];
     if (!fitsWhenFlattened(flatDoc, options)) {
         return undefined;
     }
-    return [breakParent, flatDoc];
+    return willBreak(flatDoc) ? [breakParent, flatDoc] : flatDoc;
 }
 const plugin = {
     printers: {

package/package.json

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