@blumintinc/eslint-plugin-blumint 1.20.36 → 1.20.38

package/lib/index.js

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

package/lib/rules/enforce-callback-memo.js

@@ -22,21 +22,48 @@ exports.default = (0, createRule_1.createRule)({
             return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                 node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
         }
+        // Matches both the bare hook (`useMemo(...)`, including the generic form
+        // `useCallback<T>(...)`, whose callee is still an identifier) and the
+        // namespaced form (`React.useMemo(...)`).
+        function isHookCallee(callee, hookName) {
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return callee.name === hookName;
+            }
+            return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.property.name === hookName);
+        }
         function isInsideUseCallback(node) {
             let current = node.parent;
             while (current) {
-                if (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    const { callee } = current;
-                    const isDirectUseCallback = callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        callee.name === 'useCallback';
-                    const isMemberUseCallback = callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        !callee.computed &&
-                        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        callee.property.name === 'useCallback';
-                    if (isDirectUseCallback || isMemberUseCallback) {
-                        return true;
-                    }
+                if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isHookCallee(current.callee, 'useCallback')) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        // A `useMemo` factory re-runs only when its dependencies change, so every
+        // value it produces — including JSX and the inline handlers nested in that
+        // JSX — is exactly as referentially stable as the memo itself. Demanding an
+        // extra `useCallback` there buys nothing.
+        //
+        // `useCallback` deliberately gets no such treatment: it memoizes a function
+        // that runs on every invocation, so the JSX it returns (and the inline
+        // functions in it) is rebuilt each call and stays worth reporting.
+        function isInsideUseMemoFactory(node) {
+            let child = node;
+            let current = node.parent;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isHookCallee(current.callee, 'useMemo') &&
+                    // Only the factory argument is memoized; the dependency array is not.
+                    current.arguments[0] === child) {
+                    return true;
                 }
+                child = current;
                 current = current.parent;
             }
             return false;
@@ -167,6 +194,10 @@ exports.default = (0, createRule_1.createRule)({
                 node.value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
                 return;
             }
+            // Props of JSX built inside a useMemo factory inherit the memo's stability
+            if (isInsideUseMemoFactory(node)) {
+                return;
+            }
             const { expression } = node.value;
             // Skip if the prop is already wrapped in useCallback or useMemo
             if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&

package/lib/rules/enforce-unique-cursor-headers.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceUniqueCursorHeaders = exports.RULE_NAME = void 0;
 const path_1 = __importDefault(require("path"));
 const minimatch_1 = require("minimatch");
+const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const DEFAULT_OPTIONS = {
     requiredPatterns: ['**/*.{ts,tsx,js,jsx}'],
@@ -212,6 +213,62 @@ const analyzeHeaderGroups = (candidateGroups, options) => {
         });
     return { primaryHeader, duplicateGroups, splitHeaderGroups };
 };
+/**
+ * A template made of nothing but comments is safe to prepend to any file;
+ * anything else (bare text, trailing code) would be inserted as source and can
+ * leave the file unparseable.
+ */
+const isCommentOnly = (template) => template
+    .replace(/\/\*[\s\S]*?\*\//gu, '')
+    .replace(/\/\/[^\n]*/gu, '')
+    .trim().length === 0;
+const toTemplateComment = (template, raw, offset) => {
+    const isBlock = raw.startsWith('/*');
+    const precedingText = template.slice(0, offset);
+    const startLine = precedingText.split('\n').length;
+    const startColumn = offset - (precedingText.lastIndexOf('\n') + 1);
+    const rawLines = raw.split('\n');
+    const lastLine = rawLines[rawLines.length - 1];
+    return {
+        type: isBlock ? utils_1.AST_TOKEN_TYPES.Block : utils_1.AST_TOKEN_TYPES.Line,
+        /** Header detection normalizes the raw comment value, so drop only the delimiters. */
+        value: isBlock ? raw.slice(2, -2) : raw.slice(2),
+        range: [offset, offset + raw.length],
+        loc: {
+            start: { line: startLine, column: startColumn },
+            end: {
+                line: startLine + rawLines.length - 1,
+                column: rawLines.length > 1 ? lastLine.length : startColumn + raw.length,
+            },
+        },
+    };
+};
+const parseTemplateComments = (template) => {
+    const commentPattern = /\/\*[\s\S]*?\*\/|\/\/[^\n]*/gu;
+    const comments = [];
+    for (let match = commentPattern.exec(template); match !== null; match = commentPattern.exec(template)) {
+        comments.push(toTemplateComment(template, match[0], match.index));
+    }
+    return comments;
+};
+/**
+ * A fixer must remove its own trigger. Inserting a template the rule itself
+ * would not accept as a header leaves `missingHeader` reported, so ESLint's fix
+ * loop re-inserts the template on every pass until it hits the pass ceiling.
+ *
+ * Whether a template is acceptable is not a property of its text alone: the
+ * rule groups comments first and demands that a single group carry every tag,
+ * so `allowSplitHeaders` and block adjacency decide the answer. Running the
+ * template through the same grouping the rule applies to real files keeps the
+ * fixer convergent by construction instead of by a second approximation.
+ */
+const canTemplateSatisfyRule = (template, options, excludedAtDirectives) => {
+    if (options.requiredTags.length === 0 || !isCommentOnly(template)) {
+        return false;
+    }
+    const candidateGroups = collectHeaderGroups(parseTemplateComments(template), options, excludedAtDirectives);
+    return (analyzeHeaderGroups(candidateGroups, options).primaryHeader !== undefined);
+};
 const computeHeaderInsertion = (sourceText, headerTemplate) => {
     const headerText = buildHeaderInsertionText(headerTemplate);
     if (!sourceText.startsWith('#!')) {
@@ -225,8 +282,7 @@ const computeHeaderInsertion = (sourceText, headerTemplate) => {
     /** Insert after shebang line */
     return { index: shebangNewlineIndex + 1, text: headerText };
 };
-const reportMissingHeader = (context, fileName, sourceText, options) => {
-    const template = options.headerTemplate;
+const reportMissingHeader = (context, fileName, sourceText, options, template) => {
     context.report({
         loc: { line: 1, column: 0 },
         messageId: 'missingHeader',
@@ -331,6 +387,10 @@ exports.enforceUniqueCursorHeaders = (0, createRule_1.createRule)({
         const fileName = context.getFilename();
         const matchPath = fileName.split(path_1.default.sep).join('/');
         const excludedAtDirectives = new Set(options.excludedAtDirectives);
+        const fixableTemplate = options.headerTemplate !== null &&
+            canTemplateSatisfyRule(options.headerTemplate, options, excludedAtDirectives)
+            ? options.headerTemplate
+            : null;
         if (fileName === '<input>') {
             return {};
         }
@@ -353,7 +413,7 @@ exports.enforceUniqueCursorHeaders = (0, createRule_1.createRule)({
                 const candidateGroups = collectHeaderGroups(topComments, options, excludedAtDirectives);
                 const { primaryHeader, duplicateGroups, splitHeaderGroups } = analyzeHeaderGroups(candidateGroups, options);
                 if (!primaryHeader) {
-                    reportMissingHeader(context, fileName, sourceText, options);
+                    reportMissingHeader(context, fileName, sourceText, options, fixableTemplate);
                     return;
                 }
                 reportDuplicates(context, duplicateGroups, sourceText);

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.38",
+    "date": "2026-07-30T20:52:16.921Z",
+    "rules": [
+      {
+        "name": "enforce-callback-memo",
+        "changeType": "fix",
+        "issues": [
+          1465
+        ],
+        "summary": "allow an inline callback inside a useMemo factory (closes #1465)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.37",
+    "date": "2026-07-30T18:07:02.175Z",
+    "rules": [
+      {
+        "name": "enforce-unique-cursor-headers",
+        "changeType": "fix",
+        "issues": [
+          1461
+        ],
+        "summary": "only autofix a template that satisfies the rule (closes #1461)"
+      }
+    ]
+  },
   {
     "version": "1.20.36",
     "date": "2026-07-30T17:05:52.383Z",