@blumintinc/eslint-plugin-blumint 1.20.68 → 1.20.70

package/lib/rules/use-latest-callback.js

@@ -4,6 +4,13 @@ exports.useLatestCallback = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+/**
+ * Matches Prettier's own default. Dropping the dependency array lets the call
+ * collapse onto one line, so the fixer decides a line break a formatter owns: a
+ * line it emits past this width is rewritten on the next `prettier --write`, and
+ * fails `prettier --check` in the meantime.
+ */
+const DEFAULT_PRINT_WIDTH = 80;
 const LATEST_CALLBACK_MODULE = 'use-latest-callback';
 const LATEST_CALLBACK_HOOK = 'useLatestCallback';
 /**
@@ -44,6 +51,7 @@ const findLatestCallbackImport = (program) => {
     }
     return null;
 };
+const isComma = (token) => !!token && token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === ',';
 /** The leading whitespace of the line the offset sits on. */
 const indentationAt = (sourceCode, offset) => {
     const text = sourceCode.getText();
@@ -51,6 +59,75 @@ const indentationAt = (sourceCode, offset) => {
     const match = /^[ \t]*/.exec(text.slice(lineStart, offset));
     return match ? match[0] : '';
 };
+/** The indentation of an offset that starts its own line, else null. */
+const ownLineIndentAt = (sourceCode, offset) => {
+    const text = sourceCode.getText();
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    const lead = text.slice(lineStart, offset);
+    return lead.trim() === '' ? lead : null;
+};
+/**
+ * The file's own nesting step, taken as the most common indentation increase
+ * between consecutive lines. Reading it from the source keeps emitted code in
+ * the author's units instead of assuming a two-space, space-indented file.
+ */
+const indentUnitOf = (sourceCode) => {
+    const text = sourceCode.getText();
+    const blockComments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.type === utils_1.AST_TOKEN_TYPES.Block)
+        .map((comment) => comment.range);
+    // A block comment's interior lines carry whatever alignment the comment uses
+    // — the `*` one column in from its own indentation, or, for commented-out
+    // code, the original code's depths. Neither is a nesting step of the file, and
+    // counting them makes a JSDoc-heavy file look 1-space indented. Keying on the
+    // comment's range rather than a leading `*` also covers a body without them.
+    const continuesBlockComment = (offset) => blockComments.some(([start, end]) => start < offset && offset < end);
+    const frequencies = new Map();
+    let previous = '';
+    let offset = 0;
+    for (const line of text.split('\n')) {
+        const lineStart = offset;
+        offset += line.length + 1;
+        if (line.trim() === '') {
+            continue;
+        }
+        if (continuesBlockComment(lineStart)) {
+            continue;
+        }
+        const match = /^[ \t]*/.exec(line);
+        const indent = match ? match[0] : '';
+        if (indent.length > previous.length && indent.startsWith(previous)) {
+            const delta = indent.slice(previous.length);
+            frequencies.set(delta, (frequencies.get(delta) ?? 0) + 1);
+        }
+        previous = indent;
+    }
+    let unit = '  ';
+    let best = 0;
+    for (const [delta, count] of frequencies) {
+        if (count > best) {
+            unit = delta;
+            best = count;
+        }
+    }
+    return unit;
+};
+/** The source with every planned edit applied, used to measure emitted lines. */
+const applyEdits = (text, edits) => {
+    const ordered = [...edits].sort((a, b) => b.range[0] - a.range[0]);
+    let result = text;
+    for (const edit of ordered) {
+        result = `${result.slice(0, edit.range[0])}${edit.text}${result.slice(edit.range[1])}`;
+    }
+    return result;
+};
+/** The length of the line `offset` sits on. */
+const lineLengthAt = (text, offset) => {
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    const lineBreak = text.indexOf('\n', offset);
+    return (lineBreak === -1 ? text.length : lineBreak) - lineStart;
+};
 /**
  * Ranges whose interior line breaks carry string data rather than formatting.
  * A multi-line template literal (or a string spliced together with line
@@ -65,42 +142,42 @@ const stringDataRangesOf = (sourceCode, node) => sourceCode
     token.loc.start.line !== token.loc.end.line)
     .map((token) => token.range);
 /**
- * The callback's text re-indented for the line the rewritten call puts it on.
+ * A per-line transform moving text written at `fromIndent` to `toIndent`, or
+ * null when neither indentation is a prefix of the other (tabs against spaces),
+ * where no delta can be applied without corrupting the layout.
+ */
+const lineShifterBetween = (fromIndent, toIndent) => {
+    if (fromIndent === toIndent) {
+        return (line) => line;
+    }
+    if (fromIndent.startsWith(toIndent)) {
+        const removed = fromIndent.slice(toIndent.length);
+        return (line) => line.startsWith(removed) ? line.slice(removed.length) : line;
+    }
+    if (toIndent.startsWith(fromIndent)) {
+        const added = toIndent.slice(fromIndent.length);
+        return (line) => `${added}${line}`;
+    }
+    return null;
+};
+/**
+ * The callback's text with its continuation lines moved from the depth it was
+ * written at to `toIndent`, or null when that move is not expressible.
  *
- * Dropping the dependency array lets the call collapse onto one line, and when
- * the original spelled the callback on a line of its own that collapse removes
- * exactly one nesting level. Emitting the callback verbatim would leave every
- * interior line indented for the level it no longer occupies (issue #1559), so
- * each line moves by the difference between the callback's original indentation
- * and the indentation of the line the call starts on. Preserving the original
- * multi-line layout instead is not an option: a lone function argument is
- * hugged onto the call line by the formatter, so the broken-out form would be
- * reformatted away on the next write.
+ * Dropping the dependency array changes the nesting level the callback sits at,
+ * so emitting it verbatim would leave every interior line indented for a level
+ * it no longer occupies (issue #1559). The first line is excluded because it is
+ * spliced in directly after the call's open paren (or after a fresh indent when
+ * the call is broken open), so it has no indentation of its own left to adjust.
  */
-const reindentedCallbackText = (sourceCode, call, callback) => {
+const reindentedText = (sourceCode, callback, fromIndent, toIndent) => {
     const text = sourceCode.getText(callback);
-    const callIndent = indentationAt(sourceCode, call.range[0]);
-    const callbackIndent = indentationAt(sourceCode, callback.range[0]);
-    // A callback already on the call's line loses no nesting level, so its body
-    // must be reproduced byte for byte.
-    if (callIndent === callbackIndent) {
+    if (!text.includes('\n')) {
         return text;
     }
-    const shiftLine = (() => {
-        if (callbackIndent.startsWith(callIndent)) {
-            const removed = callbackIndent.slice(callIndent.length);
-            return (line) => line.startsWith(removed) ? line.slice(removed.length) : line;
-        }
-        if (callIndent.startsWith(callbackIndent)) {
-            const added = callIndent.slice(callbackIndent.length);
-            return (line) => `${added}${line}`;
-        }
-        // Indent characters that disagree give no delta that can be applied
-        // without corrupting the layout, so the text is left as the author wrote it.
-        return null;
-    })();
+    const shiftLine = lineShifterBetween(fromIndent, toIndent);
     if (!shiftLine) {
-        return text;
+        return null;
     }
     const stringData = stringDataRangesOf(sourceCode, callback);
     const carriesStringData = (offset) => stringData.some(([start, end]) => start < offset && offset < end);
@@ -110,8 +187,6 @@ const reindentedCallbackText = (sourceCode, call, callback) => {
         .map((line, index) => {
         const lineStart = offset;
         offset += line.length + 1;
-        // The first line is spliced in after the call's open paren, so it has no
-        // indentation of its own left to adjust.
         if (index === 0 || line.trim() === '' || carriesStringData(lineStart)) {
             return line;
         }
@@ -119,6 +194,75 @@ const reindentedCallbackText = (sourceCode, call, callback) => {
     })
         .join('\n');
 };
+/**
+ * The callback's text for the collapsed, single-line call form. An indentation
+ * delta that cannot be applied leaves the text as the author wrote it, which is
+ * still valid code at the depth the formatter will correct it from.
+ */
+const collapsedCallbackText = (sourceCode, call, callback) => reindentedText(sourceCode, callback, indentationAt(sourceCode, callback.range[0]), indentationAt(sourceCode, call.range[0])) ?? sourceCode.getText(callback);
+/**
+ * Whether Prettier answers an over-long call by breaking the argument list
+ * open. It does for an arrow, and for a parameter-less function expression —
+ * but a function expression WITH parameters is instead hugged onto the call
+ * line with its parameter list broken, a shape this fixer cannot author. Left
+ * collapsed, such a call at least keeps the first line Prettier keeps.
+ */
+const breaksOpenWhenLong = (callback) => callback.type !== utils_1.AST_NODE_TYPES.FunctionExpression ||
+    callback.params.length === 0;
+/**
+ * Whether the callback's own head — its parameter list, up to where its body
+ * begins — is spelled across several lines. An arrow written that way is never
+ * hugged onto the call's line, because that would leave the call's open paren
+ * and the arrow's dangling at the end of one line; Prettier breaks the argument
+ * list open instead however short the collapsed line measures. A function
+ * expression is the exception handled above: its broken parameter list IS hugged.
+ */
+const headSpansLines = (sourceCode, callback) => callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+    sourceCode
+        .getText()
+        .slice(callback.range[0], callback.body.range[0])
+        .includes('\n');
+/**
+ * Whether the rewritten call should end its argument list with a comma. The
+ * answer is the formatter's `trailingComma` setting, which is read off the call
+ * being rewritten whenever it was already broken open — that is exactly the
+ * shape the setting governs. A call the author kept on one line says nothing
+ * about it, so the modern default (and Prettier's own, from v3) is assumed.
+ */
+const wantsTrailingComma = (sourceCode, call) => {
+    const lastArgument = call.arguments[call.arguments.length - 1];
+    const closeParen = sourceCode.getLastToken(call);
+    if (!lastArgument || !closeParen) {
+        return true;
+    }
+    if (isComma(sourceCode.getTokenBefore(closeParen))) {
+        return true;
+    }
+    return closeParen.loc.start.line === lastArgument.loc.end.line;
+};
+/**
+ * The rewritten call with its argument list broken open — the callee on its own
+ * line, the callback one nesting step in, and the closing paren back at the
+ * statement's indentation. Null when the callback's lines cannot be moved to
+ * that depth, which asks the caller to keep the collapsed form.
+ */
+const brokenOpenCallText = (sourceCode, call, callback, head, indentUnit) => {
+    const callIndent = indentationAt(sourceCode, call.range[0]);
+    // A callback the author already broke onto its own line keeps the exact
+    // indentation it was written at, so that layout survives byte for byte.
+    const ownLineIndent = ownLineIndentAt(sourceCode, callback.range[0]);
+    const calleeIndent = ownLineIndent !== null &&
+        ownLineIndent.length > callIndent.length &&
+        ownLineIndent.startsWith(callIndent)
+        ? ownLineIndent
+        : `${callIndent}${indentUnit}`;
+    const moved = reindentedText(sourceCode, callback, indentationAt(sourceCode, callback.range[0]), calleeIndent);
+    if (moved === null) {
+        return null;
+    }
+    const comma = wantsTrailingComma(sourceCode, call) ? ',' : '';
+    return `${head}(\n${calleeIndent}${moved}${comma}\n${callIndent})`;
+};
 exports.useLatestCallback = (0, createRule_1.createRule)({
     name: 'use-latest-callback',
     meta: {
@@ -128,13 +272,27 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         fixable: 'code',
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    printWidth: {
+                        type: 'number',
+                        minimum: 1,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             useLatestCallback: 'Replace {{currentHook}} with {{recommendedHook}} from "use-latest-callback" so the callback keeps a stable reference while still reading the latest props/state. useCallback recreates functions whenever dependencies change, which can trigger needless renders and stale closures. Drop the dependency array when switching to {{recommendedHook}}.',
         },
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [{}],
+    create(context, [options]) {
+        const printWidth = typeof options.printWidth === 'number' && options.printWidth > 0
+            ? options.printWidth
+            : DEFAULT_PRINT_WIDTH;
         const filename = context.getFilename();
         if (filename.includes('/node_modules/')) {
             return {};
@@ -360,9 +518,6 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                 // The react import statement participates in the change set only when
                 // it binds useCallback or anchors a React.useCallback member call.
                 const touchesImport = specifiers.length > 0 || hasReactMemberUseCallback;
-                const isComma = (token) => !!token &&
-                    token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
-                    token.value === ',';
                 /**
                  * Splices out one named specifier and the comma that separates it from
                  * the list, touching nothing else. Re-emitting the surviving specifiers
@@ -480,13 +635,46 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                     }
                     return fixes;
                 };
-                const conversionFix = (fixer, conversion) => {
-                    const callbackText = reindentedCallbackText(sourceCode, conversion.node, conversion.node.arguments[0]);
-                    const typeParams = conversion.node.typeParameters
-                        ? sourceCode.getText(conversion.node.typeParameters)
-                        : '';
-                    // Replace useCallback with useLatestCallback and remove the dependency array
-                    return fixer.replaceText(conversion.node, `${recommendedHook}${typeParams}(${callbackText})`);
+                /**
+                 * The replacement text for every batched call, collapsed onto one line
+                 * except where that line would overrun the print width.
+                 *
+                 * Prettier hugs a lone function argument onto the call line while it
+                 * fits, so collapsing is the shape that survives the next write — and
+                 * over-wrapping is not the safe direction, since a broken-open call
+                 * short enough to fit is collapsed straight back. Past the width the
+                 * two swap places, so the emitted line is MEASURED against the source
+                 * with every collapse already applied, rather than predicted from the
+                 * call's parts (issue #1579).
+                 */
+                const conversionTexts = () => {
+                    const headOf = (call) => `${recommendedHook}${call.typeParameters ? sourceCode.getText(call.typeParameters) : ''}`;
+                    const collapsed = batchedConversions.map((conversion) => ({
+                        conversion,
+                        edit: {
+                            range: conversion.node.range,
+                            text: `${headOf(conversion.node)}(${collapsedCallbackText(sourceCode, conversion.node, conversion.node.arguments[0])})`,
+                        },
+                    }));
+                    const source = sourceCode.getText();
+                    const simulated = applyEdits(source, collapsed.map(({ edit }) => edit));
+                    const shiftBefore = (offset) => collapsed
+                        .filter(({ edit }) => edit.range[1] <= offset)
+                        .reduce((total, { edit }) => total + edit.text.length - (edit.range[1] - edit.range[0]), 0);
+                    const indentUnit = indentUnitOf(sourceCode);
+                    const texts = new Map();
+                    for (const { conversion, edit } of collapsed) {
+                        const { node } = conversion;
+                        const start = node.range[0] + shiftBefore(node.range[0]);
+                        const callback = node.arguments[0];
+                        const overflows = lineLengthAt(simulated, start) > printWidth ||
+                            headSpansLines(sourceCode, callback);
+                        const broken = overflows && breaksOpenWhenLong(callback)
+                            ? brokenOpenCallText(sourceCode, node, callback, headOf(node), indentUnit)
+                            : null;
+                        texts.set(node, broken ?? edit.text);
+                    }
+                    return texts;
                 };
                 // Every call-site conversion and the import rewrite ride on ONE fix
                 // from ONE report. ESLint discards a multi-part fix wholesale when any
@@ -512,8 +700,9 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                         if (!batchedConversions.every(reachesHook)) {
                             return null;
                         }
+                        const texts = conversionTexts();
                         return [
-                            ...batchedConversions.map((conversion) => conversionFix(fixer, conversion)),
+                            ...batchedConversions.map((conversion) => fixer.replaceText(conversion.node, texts.get(conversion.node))),
                             ...importFixes(fixer),
                         ];
                     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.68",
+  "version": "1.20.70",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,98 @@
 [
+  {
+    "version": "1.20.70",
+    "date": "2026-08-01T23:31:02.214Z",
+    "rules": [
+      {
+        "name": "class-methods-read-top-to-bottom",
+        "changeType": "fix",
+        "issues": [
+          1592
+        ],
+        "summary": "preserve the whitespace separating reordered class members (closes #1592)"
+      },
+      {
+        "name": "no-useless-usememo-primitives",
+        "changeType": "fix",
+        "issues": [
+          1591
+        ],
+        "summary": "decline the autofix when inlining would strand a comment (closes #1591)"
+      },
+      {
+        "name": "parallelize-async-operations",
+        "changeType": "fix",
+        "issues": [
+          1589
+        ],
+        "summary": "preserve comments between merged awaits (closes #1589)"
+      },
+      {
+        "name": "prefer-map-over-conditional-dispatch",
+        "changeType": "fix",
+        "issues": [
+          1590
+        ],
+        "summary": "preserve branch comments in the generated map (closes #1590)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.69",
+    "date": "2026-08-01T20:48:40.484Z",
+    "rules": [
+      {
+        "name": "enforce-early-destructuring",
+        "changeType": "fix",
+        "issues": [
+          1580
+        ],
+        "summary": "stop parenthesizing a source that already binds tighter than ?? (closes #1580)"
+      },
+      {
+        "name": "enforce-render-hits-memoization",
+        "changeType": "fix",
+        "issues": [
+          1585,
+          1586,
+          1588
+        ],
+        "summary": "report shorthand props (closes #1588); accept a module-scope function as already stable (closes #1586); recognise useLatestCallback as a memoization boundary (closes #1585)"
+      },
+      {
+        "name": "enforce-transform-memoization",
+        "changeType": "fix",
+        "issues": [
+          1584
+        ],
+        "summary": "recognise useLatestCallback as a stabilizing wrapper (closes #1584)"
+      },
+      {
+        "name": "optimize-object-boolean-conditions",
+        "changeType": "fix",
+        "issues": [
+          1581
+        ],
+        "summary": "see through `as const` when judging a primitive (closes #1581)"
+      },
+      {
+        "name": "prefer-type-over-interface",
+        "changeType": "fix",
+        "issues": [
+          1583
+        ],
+        "summary": "exempt merged interface declarations (closes #1583)"
+      },
+      {
+        "name": "use-latest-callback",
+        "changeType": "fix",
+        "issues": [
+          1579
+        ],
+        "summary": "keep the call broken open when collapsing overflows the print width (closes #1579)"
+      }
+    ]
+  },
   {
     "version": "1.20.68",
     "date": "2026-08-01T18:03:14.950Z",