@blumintinc/eslint-plugin-blumint 1.19.6 → 1.19.8

package/lib/index.js

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

package/lib/rules/no-redundant-this-params.js

@@ -77,6 +77,47 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
             }
             return [];
         }
+        function isBindingExportedInScope(scopeBody, bindingName) {
+            // A class bound at module (or namespace) scope can be exported by a
+            // statement separate from its declaration — `export { Foo }`,
+            // `export { Foo as Bar }`, `export default Foo`, or `export = Foo`. Any of
+            // these exposes it to subclassing from another file just as an inline
+            // export does.
+            for (const statement of scopeBody) {
+                if (statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+                    !statement.source) {
+                    for (const specifier of statement.specifiers) {
+                        if (specifier.local.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            specifier.local.name === bindingName) {
+                            return true;
+                        }
+                    }
+                }
+                if (statement.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration &&
+                    statement.declaration.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    statement.declaration.name === bindingName) {
+                    return true;
+                }
+                if (statement.type === utils_1.AST_NODE_TYPES.TSExportAssignment &&
+                    statement.expression.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    statement.expression.name === bindingName) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function getEnclosingScopeBody(node) {
+            if (!node) {
+                return null;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.Program) {
+                return node.body;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.TSModuleBlock) {
+                return node.body;
+            }
+            return null;
+        }
         function isExportedClass(node) {
             const parent = node.parent;
             if (!parent) {
@@ -86,14 +127,33 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
                 parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
                 return true;
             }
-            // `export const Foo = class { ... }` exposes the class expression to other
-            // files just as an exported declaration does.
+            // A `class Foo {}` declaration exported by a later `export { Foo }` /
+            // `export default Foo` in the same scope is still reachable cross-file.
+            if (node.type === utils_1.AST_NODE_TYPES.ClassDeclaration &&
+                node.id &&
+                (parent.type === utils_1.AST_NODE_TYPES.Program ||
+                    parent.type === utils_1.AST_NODE_TYPES.TSModuleBlock)) {
+                const scopeBody = getEnclosingScopeBody(parent);
+                if (scopeBody && isBindingExportedInScope(scopeBody, node.id.name)) {
+                    return true;
+                }
+            }
+            // `export const Foo = class { ... }`, or `const Foo = class {}` exported by
+            // a later statement, both expose the class expression like an exported
+            // declaration does.
             if (node.type === utils_1.AST_NODE_TYPES.ClassExpression &&
-                parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
                 const declaration = parent.parent;
                 const exportNode = declaration?.parent;
-                return (exportNode?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
-                    exportNode?.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration);
+                if (exportNode?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+                    exportNode?.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
+                    return true;
+                }
+                const scopeBody = getEnclosingScopeBody(exportNode);
+                if (scopeBody && isBindingExportedInScope(scopeBody, parent.id.name)) {
+                    return true;
+                }
             }
             return false;
         }

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

@@ -31,6 +31,20 @@ const ASTHelpers_1 = require("../utils/ASTHelpers");
 const DEFAULT_MIN_STATEMENTS = 8;
 const DEFAULT_MIN_LINES = 12;
 const DEFAULT_IGNORE_CLOSURES = true;
+/**
+ * Next.js framework-reserved page exports. Next.js only recognizes these when
+ * they are exported from the page file itself, so they categorically cannot be
+ * moved to a `util/` file and re-imported — the rule's suggested remediation is
+ * impossible to follow for them. Mirrors the exemption precedent set in
+ * `semantic-function-prefixes` (issue #333).
+ */
+const NEXTJS_RESERVED_PAGE_EXPORTS = new Set([
+    'getServerSideProps',
+    'getStaticProps',
+    'getStaticPaths',
+    'middleware',
+    'config',
+]);
 /**
  * Collects all identifiers referenced in a node body (for closure detection).
  * Returns the set of identifier names referenced anywhere inside the node,
@@ -289,6 +303,23 @@ function isExemptFile(filename) {
         return true;
     return false;
 }
+/**
+ * Returns true if the candidate is a Next.js framework-reserved page export
+ * (`getServerSideProps`, `getStaticProps`, `getStaticPaths`, `middleware`,
+ * `config`) living in a file under a `pages/` directory. Keying off the
+ * `pages/` path segment covers both the `src/pages/**` and bare `pages/**`
+ * Pages Router layouts. These exports must stay in the page file — Next.js only
+ * recognizes them there — so they can never be extracted to their own util
+ * file, regardless of size or closure geometry.
+ */
+function isNextReservedPageExport(name, filename) {
+    if (!NEXTJS_RESERVED_PAGE_EXPORTS.has(name))
+        return false;
+    if (!filename)
+        return false;
+    const normalized = filename.replace(/\\/g, '/');
+    return /(^|\/)pages\//.test(normalized);
+}
 /**
  * Returns true if the module top-level self-invokes one of its own functions,
  * e.g. `void autoRunIfMain();` or `main();`. This is the signature of a CLI
@@ -538,7 +569,15 @@ exports.preferUtilityFunctionOwnFile = (0, createRule_1.createRule)({
                     return;
                 // For each candidate, determine whether to flag
                 for (const info of topLevelFunctions) {
-                    const { node, name, fn, isDefaultExport } = info;
+                    const { node, name, fn, isDefaultExport, isNamedExport } = info;
+                    // --- Exclusion: Next.js reserved page export ---
+                    // `getServerSideProps`/`getStaticProps`/`getStaticPaths`/`middleware`/
+                    // `config` are framework-reserved: Next.js only recognizes them when
+                    // exported from the page file itself, so they can never move to a
+                    // util/ file. Scoped to named exports under a `pages/` directory so it
+                    // does not over-broaden to same-named functions elsewhere.
+                    if (isNamedExport && isNextReservedPageExport(name, filename))
+                        continue;
                     // --- Exclusion: is a hook ---
                     if (isHookName(name))
                         continue;

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

@@ -323,9 +323,19 @@ function computeExpectedOrder(functions, options) {
 }
 function getStatementRangeWithComments(statement, sourceCode, consumedComments, nextStatement) {
     const filterComments = (comments) => (comments || []).filter((comment) => !consumedComments || !consumedComments.has(comment));
-    const commentsBefore = filterComments(sourceCode.getCommentsBefore(statement) || []);
+    // A comment sharing a line with the code token immediately before it is a
+    // trailing comment of that preceding statement (e.g. `const x = 2; // note`),
+    // not a leading comment of the node beneath it. Attributing it to the node
+    // below would drag an interleaved statement's own end-of-line comment along
+    // when the following function is relocated. Only own-line comments count as
+    // leading comments.
+    const leadingCommentsOf = (target) => filterComments(sourceCode.getCommentsBefore(target) || []).filter((comment) => {
+        const tokenBefore = sourceCode.getTokenBefore(comment);
+        return (!tokenBefore || tokenBefore.loc.end.line !== comment.loc.start.line);
+    });
+    const commentsBefore = leadingCommentsOf(statement);
     const nextLeadingComments = nextStatement
-        ? new Set(filterComments(sourceCode.getCommentsBefore(nextStatement) || []))
+        ? new Set(leadingCommentsOf(nextStatement))
         : new Set();
     const trailingCandidates = filterComments(sourceCode.getCommentsAfter(statement) || []).filter((comment) => !nextLeadingComments.has(comment));
     const start = commentsBefore.length > 0
@@ -457,9 +467,15 @@ exports.verticallyGroupRelatedFunctions = (0, createRule_1.createRule)({
                     .sort((a, b) => a.originalIndex - b.originalIndex);
                 const consumedComments = new Set();
                 const statementRanges = new Map();
-                sourceOrderedInfos.forEach((info, idx) => {
-                    const nextInfo = sourceOrderedInfos[idx + 1];
-                    const [rangeStart, rangeEnd] = getStatementRangeWithComments(info.statementNode, sourceCode, consumedComments, nextInfo?.statementNode);
+                sourceOrderedInfos.forEach((info) => {
+                    // Bound each function's trailing comments by the statement that
+                    // physically follows it in the block — which may be an interleaved
+                    // non-function statement, not the next function — so an interleaved
+                    // statement's own leading comment is never swallowed into the
+                    // function above it.
+                    const bodyIndex = node.body.indexOf(info.statementNode);
+                    const nextStatement = bodyIndex >= 0 ? node.body[bodyIndex + 1] : undefined;
+                    const [rangeStart, rangeEnd] = getStatementRangeWithComments(info.statementNode, sourceCode, consumedComments, nextStatement);
                     statementRanges.set(info.statementNode, [rangeStart, rangeEnd]);
                 });
                 const firstFunctionIndex = node.body.findIndex((statement) => functionStatements.has(statement));
@@ -488,12 +504,22 @@ exports.verticallyGroupRelatedFunctions = (0, createRule_1.createRule)({
                             // Real modules interleave type aliases, consts, and top-level
                             // calls (e.g. `void autoRunIfMain();`) between functions. Rather
                             // than bail, reorder only the function statements among their own
-                            // slots, leaving every other statement exactly where it is. Plain
-                            // node ranges keep the edits disjoint (no comment-span overlap
-                            // with the interleaved statements).
+                            // slots, leaving every other statement exactly where it is. Both
+                            // the destination slot and the source text use the same
+                            // comment-inclusive ranges Path A relies on, so each function's
+                            // leading JSDoc travels with it instead of being left orphaned in
+                            // its old slot. The precomputed `statementRanges` already exclude
+                            // each interleaved statement's own leading comments (they are
+                            // treated as the next function's leading comments), so the widened
+                            // edits stay disjoint from one another and from the interleaved
+                            // statements — no comment-span overlap.
                             return sourceOrderedInfos.map((info, idx) => {
                                 const target = expectedOrderInfos[idx];
-                                return fixer.replaceTextRange(info.statementNode.range, sourceCode.getText(target.statementNode));
+                                const destRange = statementRanges.get(info.statementNode) ||
+                                    getStatementRangeWithComments(info.statementNode, sourceCode);
+                                const [targetStart, targetEnd] = statementRanges.get(target.statementNode) ||
+                                    getStatementRangeWithComments(target.statementNode, sourceCode);
+                                return fixer.replaceTextRange(destRange, sourceCode.text.slice(targetStart, targetEnd));
                             });
                         }
                         const [start] = statementRanges.get(node.body[firstFunctionIndex]) ||

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.19.8",
+    "date": "2026-07-17T00:25:07.461Z",
+    "rules": [
+      {
+        "name": "prefer-utility-function-own-file",
+        "changeType": "fix",
+        "issues": [
+          1311
+        ],
+        "summary": "exempt Next.js reserved page exports (closes #1311)"
+      },
+      {
+        "name": "vertically-group-related-functions",
+        "changeType": "fix",
+        "issues": [
+          1310
+        ],
+        "summary": "keep interleaved statements' own comments in place when reordering (refs #1310); carry leading JSDoc with reordered functions across interleaved statements (closes #1310)"
+      }
+    ]
+  },
+  {
+    "version": "1.19.7",
+    "date": "2026-07-16T01:36:53.555Z",
+    "rules": [
+      {
+        "name": "no-redundant-this-params",
+        "changeType": "fix",
+        "issues": [
+          1309
+        ],
+        "summary": "treat trailing-export classes as reachable"
+      }
+    ]
+  },
   {
     "version": "1.19.6",
     "date": "2026-07-16T01:27:07.130Z",