@blumintinc/eslint-plugin-blumint 1.19.0 → 1.19.2

package/lib/index.js

@@ -222,7 +222,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.19.0',
+        version: '1.19.2',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/consistent-callback-naming.js

@@ -26,6 +26,19 @@ var __importStar = (this && this.__importStar) || function (mod) {
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
+// The "handle" prefix the rule targets is the verb-phrase pattern
+// `handle<Something>` — six letters immediately followed by a capitalized word
+// (handleClick, handleSubmit, handleFormSubmit). When "handle" is followed by a
+// lowercase letter the six letters are part of an ordinary word, not the prefix:
+// the past participle "handled" (and derived names like "handledFingerprints"),
+// the noun "handler(s)", "handles", "handling", the adjective "handleable". Those
+// are plain identifiers, so flagging them — and worse, autofix-stripping the
+// leading "handle" to leave nonsense like `d`/`dFingerprints` — silently corrupts
+// unrelated code (Bug #1301). A bare "handle" is likewise a whole word, not a
+// prefix.
+function hasHandlePrefix(name) {
+    return /^handle[A-Z]/.test(name);
+}
 module.exports = (0, createRule_1.createRule)({
     name: 'consistent-callback-naming',
     meta: {
@@ -48,9 +61,15 @@ module.exports = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const parserServices = context.parserServices;
-        // Check if we have access to TypeScript services
+        // This rule is type-aware, but a single eslint invocation routinely mixes
+        // in-project files with out-of-project ones (plain-Node `.mjs` scripts,
+        // config files, etc.) that the TS `project` never parses. Throwing here
+        // aborts rule loading for the ENTIRE run — one out-of-project file in argv
+        // kills diagnostics for every file (Bug #1302). Degrade gracefully instead:
+        // skip files without type information with a no-op visitor, matching how
+        // @typescript-eslint rules tolerate missing parser services per file.
         if (!parserServices?.program || !parserServices?.esTreeNodeToTSNodeMap) {
-            throw new Error('You have to enable the `project` setting in parser options to use this rule');
+            return {};
         }
         const checker = parserServices.program.getTypeChecker();
         function isReactComponentType(node) {
@@ -251,16 +270,7 @@ module.exports = (0, createRule_1.createRule)({
             // Check function declarations and variable declarations for callback functions
             'FunctionDeclaration, VariableDeclarator'(node) {
                 const functionName = node.id?.type === 'Identifier' ? node.id.name : undefined;
-                if (functionName && functionName.startsWith('handle') && node.id) {
-                    // Skip autofixing for "handler" and "handlers"
-                    if (functionName === 'handler' || functionName === 'handlers') {
-                        context.report({
-                            node,
-                            messageId: 'callbackFunctionPrefix',
-                            data: { functionName },
-                        });
-                        return;
-                    }
+                if (functionName && hasHandlePrefix(functionName) && node.id) {
                     // Skip autofixing for class parameters and getters
                     const parent = node.parent;
                     if (parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
@@ -342,17 +352,8 @@ module.exports = (0, createRule_1.createRule)({
             'MethodDefinition, Property'(node) {
                 if (node.key.type === 'Identifier' &&
                     node.key.name &&
-                    node.key.name.startsWith('handle')) {
+                    hasHandlePrefix(node.key.name)) {
                     const name = node.key.name;
-                    // Skip autofixing for "handler" and "handlers"
-                    if (name === 'handler' || name === 'handlers') {
-                        context.report({
-                            node: node.key,
-                            messageId: 'callbackFunctionPrefix',
-                            data: { functionName: name },
-                        });
-                        return;
-                    }
                     // Skip autofixing for class parameters and getters
                     if (node.type === 'MethodDefinition' && node.kind === 'get') {
                         context.report({
@@ -377,7 +378,7 @@ module.exports = (0, createRule_1.createRule)({
             // Check constructor parameters
             TSParameterProperty(node) {
                 if (node.parameter.type === 'Identifier' &&
-                    node.parameter.name.startsWith('handle')) {
+                    hasHandlePrefix(node.parameter.name)) {
                     context.report({
                         node,
                         messageId: 'callbackFunctionPrefix',

package/lib/rules/prefer-utility-function-own-file.d.ts

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         minStatements?: number;
@@ -5,5 +6,5 @@ type Options = [
         ignoreClosures?: boolean;
     }
 ];
-export declare const preferUtilityFunctionOwnFile: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"extractUtility", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const preferUtilityFunctionOwnFile: TSESLint.RuleModule<"extractUtility", Options, TSESLint.RuleListener>;
 export {};

package/lib/rules/prefer-utility-function-own-file.js

@@ -186,12 +186,42 @@ function countStatements(fn) {
     return 1;
 }
 /**
- * Counts the number of source lines spanned by a function node.
+ * Counts the number of significant source lines spanned by a function node —
+ * lines that carry actual code. Blank lines and comment-only lines are ignored
+ * so a function's "size" does not depend on how heavily it is commented:
+ * identical code with and without JSDoc/inline comments lints identically.
  */
-function countLines(fn) {
+function countLines(fn, sourceCode) {
     if (!fn.loc)
         return 0;
-    return fn.loc.end.line - fn.loc.start.line + 1;
+    const startLine = fn.loc.start.line;
+    const endLine = fn.loc.end.line;
+    const lines = sourceCode.lines;
+    let count = 0;
+    for (let line = startLine; line <= endLine; line++) {
+        const text = lines[line - 1] ?? '';
+        if (text.trim() === '')
+            continue;
+        // Blank out any character ranges on this line covered by a comment, then
+        // check whether any non-whitespace code remains.
+        const chars = text.split('');
+        for (const comment of sourceCode.getAllComments()) {
+            if (!comment.loc)
+                continue;
+            if (comment.loc.start.line > line || comment.loc.end.line < line) {
+                continue;
+            }
+            const from = comment.loc.start.line === line ? comment.loc.start.column : 0;
+            const to = comment.loc.end.line === line ? comment.loc.end.column : chars.length;
+            for (let col = from; col < to && col < chars.length; col++) {
+                chars[col] = ' ';
+            }
+        }
+        if (chars.join('').trim() === '')
+            continue;
+        count++;
+    }
+    return count;
 }
 /**
  * Returns the function expression node if the VariableDeclarator initializer
@@ -331,6 +361,7 @@ exports.preferUtilityFunctionOwnFile = (0, createRule_1.createRule)({
         const minLines = options.minLines ?? DEFAULT_MIN_LINES;
         const ignoreClosures = options.ignoreClosures ?? DEFAULT_IGNORE_CLOSURES;
         const filename = context.getFilename();
+        const sourceCode = context.getSourceCode();
         // Exempt test/mock/type files entirely
         if (isExemptFile(filename))
             return {};
@@ -515,7 +546,7 @@ exports.preferUtilityFunctionOwnFile = (0, createRule_1.createRule)({
                     // (already covered above, but be explicit)
                     // --- Size check: must be sizable ---
                     const stmts = countStatements(fn);
-                    const lines = countLines(fn);
+                    const lines = countLines(fn, sourceCode);
                     const isSizable = stmts >= minStatements || lines >= minLines;
                     if (!isSizable)
                         continue;
@@ -524,6 +555,12 @@ exports.preferUtilityFunctionOwnFile = (0, createRule_1.createRule)({
                         const closesOverModuleScope = functionClosesOverModuleScope(fn, topLevelBindingNames);
                         if (closesOverModuleScope)
                             continue;
+                        // Reverse-closure exemption: the candidate is the shared internal
+                        // primitive its sibling exports build on. A cohesive multi-export
+                        // utility module is already a utility file; extracting its core
+                        // would sever the file's internal cohesion.
+                        if (isReferencedBySibling(info, topLevelFunctions))
+                            continue;
                     }
                     // --- Co-location gate: file must have a distinct primary export ---
                     // The file has a distinct primary purpose if:
@@ -580,6 +617,30 @@ function functionClosesOverModuleScope(fn, topLevelBindingNames) {
     }
     return false;
 }
+/**
+ * Returns true if any *other* top-level function in the file references the
+ * candidate by name in its body. When sibling exports build on the candidate,
+ * the candidate is the module's shared internal primitive — a cohesive
+ * multi-export utility module is already a utility file, and extracting its core
+ * would orphan the siblings from the primitive they depend on.
+ *
+ * This is the mirror of the closure exemption: `functionClosesOverModuleScope`
+ * asks "does the candidate need the file?"; this asks "does the file need the
+ * candidate?". Either direction of dependency means extraction severs cohesion.
+ */
+function isReferencedBySibling(candidate, allFunctions) {
+    for (const other of allFunctions) {
+        if (other.name === candidate.name)
+            continue;
+        const body = getFunctionBody(other.fn);
+        if (!body)
+            continue;
+        const refs = collectReferencedIdentifiers(body);
+        if (refs.has(candidate.name))
+            return true;
+    }
+    return false;
+}
 /**
  * Determines whether the file has a distinct primary purpose (co-location gate).
  * A file has a distinct primary purpose if (excluding the function under test):

package/lib/rules/vertically-group-related-functions.js

@@ -259,6 +259,12 @@ function dependencyOrder(functions, direction, groupOrder) {
         });
     });
     const roots = namesInTiebreakOrder.filter((name) => (incomingCount.get(name) || 0) === 0);
+    // Remaining unemitted callers per function, seeded from incomingCount. Used
+    // (callers-first only) to defer a shared callee until every caller that
+    // reaches it has been emitted, so the shared primitive lands below all of its
+    // callers rather than being greedily inlined beneath whichever caller the DFS
+    // reaches first — which would place its other callers below their own helper.
+    const remainingCallers = new Map(incomingCount);
     const visit = (name) => {
         if (visited.has(name)) {
             return;
@@ -271,7 +277,18 @@ function dependencyOrder(functions, direction, groupOrder) {
         }
         else {
             order.push(name);
-            deps.forEach(visit);
+            for (const dep of deps) {
+                const remaining = (remainingCallers.get(dep) ?? 0) - 1;
+                remainingCallers.set(dep, remaining);
+                // Descend into the callee only once its last caller has been emitted.
+                // A shared callee is deferred here and picked up when the caller that
+                // drives its counter to zero recurses into it. If a callee is never
+                // driven to zero (e.g. a dependency cycle), the top-level sweep below
+                // still visits it, so no function is dropped from the order.
+                if (remaining <= 0) {
+                    visit(dep);
+                }
+            }
         }
     };
     // Depth-first from roots keeps each caller immediately above its own helper

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,41 @@
 [
+  {
+    "version": "1.19.2",
+    "date": "2026-07-14T07:32:08.575Z",
+    "rules": [
+      {
+        "name": "prefer-utility-function-own-file",
+        "changeType": "fix",
+        "issues": [
+          1303
+        ],
+        "summary": "exempt shared primitive of cohesive multi-export utility modules (closes #1303)"
+      },
+      {
+        "name": "vertically-group-related-functions",
+        "changeType": "fix",
+        "issues": [
+          1304
+        ],
+        "summary": "defer shared callees until all callers emitted (closes #1304)"
+      }
+    ]
+  },
+  {
+    "version": "1.19.1",
+    "date": "2026-07-14T01:28:36.352Z",
+    "rules": [
+      {
+        "name": "consistent-callback-naming",
+        "changeType": "fix",
+        "issues": [
+          1301,
+          1302
+        ],
+        "summary": "skip files without TS project services instead of aborting the run (closes #1302); require uppercase after \"handle\" so past-participle identifiers aren't stripped (closes #1301)"
+      }
+    ]
+  },
   {
     "version": "1.19.0",
     "date": "2026-07-13T23:57:00.324Z",