@blumintinc/eslint-plugin-blumint 1.20.190 → 1.20.192

package/lib/index.js

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

package/lib/rules/enforce-typescript-markdown-code-blocks.js

@@ -2,32 +2,104 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceTypescriptMarkdownCodeBlocks = void 0;
 const createRule_1 = require("../utils/createRule");
-const FENCE = '```';
-function isFenceLine(text, fenceIndex, indent) {
-    const lineEnd = text.indexOf('\n', fenceIndex);
-    const afterFence = lineEnd === -1
-        ? text.slice(fenceIndex + FENCE.length)
-        : text.slice(fenceIndex + FENCE.length, lineEnd);
-    return (afterFence.trim().length === 0 &&
-        text.slice(text.lastIndexOf('\n', fenceIndex - 1) + 1, fenceIndex) ===
-            indent);
+const BACKTICK = '`';
+const TILDE = '~';
+/** Only a run of exactly three backticks is labelable; longer runs are declined. */
+const LABELABLE_FENCE_LENGTH = 3;
+/** CommonMark opens a fenced block on a run of three or more of either marker. */
+const MIN_FENCE_LENGTH = 3;
+/**
+ * CommonMark allows a fence to be indented at most three columns. At four or
+ * more the line opens an indented code block, so its backticks are literal
+ * document content that must never be rewritten.
+ */
+const MAX_FENCE_INDENT_COLUMNS = 3;
+/** CommonMark advances a tab to the next multiple of four when measuring indent. */
+const TAB_STOP = 4;
+function splitLines(text) {
+    const lines = [];
+    let start = 0;
+    for (;;) {
+        const terminator = text.indexOf('\n', start);
+        const end = terminator === -1 ? text.length : terminator;
+        lines.push({ start, end, text: text.slice(start, end) });
+        if (terminator === -1) {
+            return lines;
+        }
+        start = terminator + 1;
+    }
 }
-function findClosingFence(text, startIndex, indent) {
-    let searchIndex = startIndex;
-    while (searchIndex < text.length) {
-        const candidate = text.indexOf(FENCE, searchIndex);
-        if (candidate === -1) {
-            return null;
+/**
+ * Reads the fence a line opens, or null when the line cannot open one.
+ * Indentation is measured in columns rather than characters so that a tab is
+ * treated as the four-column indent CommonMark says it is.
+ */
+function readFence(line) {
+    let indentColumns = 0;
+    let offset = 0;
+    while (offset < line.text.length) {
+        const char = line.text[offset];
+        if (char === ' ') {
+            indentColumns += 1;
         }
-        if (isFenceLine(text, candidate, indent)) {
-            return candidate;
+        else if (char === '\t') {
+            indentColumns += TAB_STOP - (indentColumns % TAB_STOP);
+        }
+        else {
+            break;
+        }
+        offset += 1;
+    }
+    if (indentColumns > MAX_FENCE_INDENT_COLUMNS) {
+        return null;
+    }
+    const marker = line.text[offset];
+    if (marker !== BACKTICK && marker !== TILDE) {
+        return null;
+    }
+    let runLength = 0;
+    while (line.text[offset + runLength] === marker) {
+        runLength += 1;
+    }
+    if (runLength < MIN_FENCE_LENGTH) {
+        return null;
+    }
+    return {
+        runStart: line.start + offset,
+        marker,
+        runLength,
+        indent: line.text.slice(0, offset),
+        infoString: line.text.slice(offset + runLength),
+    };
+}
+/**
+ * The line a block closes on, per CommonMark: a run of at least the opening
+ * length, of the SAME marker, at a fence indent, with nothing but whitespace
+ * after it. This locates the block's END, which is a separate question from
+ * whether the rule is willing to LABEL it.
+ */
+function findFenceCloser(lines, fromLine, opener) {
+    for (let index = fromLine; index < lines.length; index++) {
+        const fence = readFence(lines[index]);
+        if (fence !== null &&
+            fence.marker === opener.marker &&
+            fence.runLength >= opener.runLength &&
+            fence.infoString.trim().length === 0) {
+            return { line: index, fence };
         }
-        searchIndex = candidate + FENCE.length;
     }
     return null;
 }
-function isIndentOnly(value) {
-    return /^[\t ]*$/.test(value);
+/**
+ * The rule labels only a block it can delimit exactly: three backticks closed
+ * by three backticks at the same indent. A longer closing run or a differently
+ * indented one is left unlabeled by design — but the block is still SKIPPED
+ * whole, because a block the rule declines to label is a block it must not
+ * read.
+ */
+function isExactlyDelimited(opener, closer) {
+    return (closer.runLength === LABELABLE_FENCE_LENGTH &&
+        closer.indent === opener.indent);
 }
 exports.enforceTypescriptMarkdownCodeBlocks = (0, createRule_1.createRule)({
     name: 'enforce-typescript-markdown-code-blocks',
@@ -53,45 +125,51 @@ exports.enforceTypescriptMarkdownCodeBlocks = (0, createRule_1.createRule)({
             Program() {
                 const sourceCode = context.sourceCode;
                 const text = sourceCode.getText();
+                const lines = splitLines(text);
                 let index = 0;
-                while (index < text.length) {
-                    const openingFence = text.indexOf(FENCE, index);
-                    if (openingFence === -1) {
-                        break;
-                    }
-                    const lineStart = text.lastIndexOf('\n', openingFence - 1) + 1;
-                    const indent = text.slice(lineStart, openingFence);
-                    if (!isIndentOnly(indent)) {
-                        index = openingFence + FENCE.length;
+                while (index < lines.length) {
+                    const openingLine = lines[index];
+                    const fence = readFence(openingLine);
+                    if (fence === null) {
+                        index += 1;
                         continue;
                     }
-                    const lineEnd = text.indexOf('\n', openingFence + FENCE.length);
-                    if (lineEnd === -1) {
-                        break;
-                    }
-                    const infoString = text.slice(openingFence + FENCE.length, lineEnd);
-                    const closingFence = findClosingFence(text, lineEnd + 1, indent);
-                    if (closingFence === null) {
-                        index = lineEnd + 1;
-                        continue;
+                    const closing = findFenceCloser(lines, index + 1, fence);
+                    // An unclosed fence runs to the end of the file, so everything after
+                    // it is the block's literal content and there is nothing left to
+                    // scan. Resuming on the next line would read the block's interior.
+                    if (closing === null) {
+                        return;
                     }
-                    const content = text.slice(lineEnd + 1, closingFence);
-                    const hasContent = content.trim().length > 0;
-                    const hasLanguage = infoString.trim().length > 0;
-                    if (!hasLanguage && hasContent) {
-                        const locStart = sourceCode.getLocFromIndex(openingFence);
-                        const hasCarriageReturn = lineEnd > 0 && text[lineEnd - 1] === '\r';
-                        context.report({
-                            loc: {
-                                start: locStart,
-                                end: sourceCode.getLocFromIndex(lineEnd),
-                            },
-                            messageId: 'missingLanguageSpecifier',
-                            data: { line: locStart.line },
-                            fix: (fixer) => fixer.replaceTextRange([openingFence + FENCE.length, lineEnd], hasCarriageReturn ? 'typescript\r' : 'typescript'),
-                        });
+                    // A tilde fence and a run of four or more backticks are blocks this
+                    // rule declines to label, and declining to label a block means
+                    // declining to read it: its interior is literal text, triple
+                    // backticks included. So is the interior of a triple-backtick block
+                    // this rule cannot delimit exactly. Every one of them is skipped from
+                    // its opening line to past its closing line.
+                    const labelable = fence.marker === BACKTICK &&
+                        fence.runLength === LABELABLE_FENCE_LENGTH &&
+                        isExactlyDelimited(fence, closing.fence);
+                    if (labelable) {
+                        const content = text.slice(openingLine.end + 1, lines[closing.line].start);
+                        const hasContent = content.trim().length > 0;
+                        const hasLanguage = fence.infoString.trim().length > 0;
+                        if (!hasLanguage && hasContent) {
+                            const lineEnd = openingLine.end;
+                            const locStart = sourceCode.getLocFromIndex(fence.runStart);
+                            const hasCarriageReturn = lineEnd > 0 && text[lineEnd - 1] === '\r';
+                            context.report({
+                                loc: {
+                                    start: locStart,
+                                    end: sourceCode.getLocFromIndex(lineEnd),
+                                },
+                                messageId: 'missingLanguageSpecifier',
+                                data: { line: locStart.line },
+                                fix: (fixer) => fixer.replaceTextRange([fence.runStart + LABELABLE_FENCE_LENGTH, lineEnd], hasCarriageReturn ? 'typescript\r' : 'typescript'),
+                            });
+                        }
                     }
-                    index = closingFence + FENCE.length;
+                    index = closing.line + 1;
                 }
             },
         };

package/lib/rules/no-entire-object-hook-deps.js

@@ -1278,19 +1278,63 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
             return variableByReference.get(identifier) ?? null;
         }
         /**
-         * Whether deleting `element` from the dependency array would leave its
-         * binding with no reader left in the file.
+         * Every identifier that a hook dependency array holds as an entry.
          *
-         * why: a value declared and then read ONLY inside a dependency array is by
+         * why: an entry is a recompute trigger rather than a consumer of the value,
+         * so it cannot keep a declaration alive once the entries are pruned. The
+         * set is built from the rule's own notion of a dependency array — the last
+         * argument of a hook call — so it can never disagree with what the fixer
+         * edits. Keying on the identifier NODE, rather than on ancestry walked from
+         * a reference, keeps the answer available for entries the traversal has not
+         * reached yet, which is precisely the later-hook entry that #2210 turns on.
+         */
+        let dependencyEntryIdentifiers = null;
+        function collectDependencyEntryIdentifiers() {
+            if (dependencyEntryIdentifiers) {
+                return dependencyEntryIdentifiers;
+            }
+            const entries = new Set();
+            const visit = (node) => {
+                if (node.type === utils_1.AST_NODE_TYPES.CallExpression && isHookCall(node)) {
+                    const deps = node.arguments[node.arguments.length - 1];
+                    if (deps && deps.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                        for (const entry of deps.elements) {
+                            if (entry)
+                                entries.add(unwrapExpression(entry));
+                        }
+                    }
+                }
+                forEachChildNode(node, visit);
+            };
+            visit(sourceCode.ast);
+            dependencyEntryIdentifiers = entries;
+            return entries;
+        }
+        /**
+         * Whether removing `element`'s binding from every dependency array that
+         * lists it would leave the binding with no reader in the file.
+         *
+         * why: a value declared and then read ONLY inside dependency arrays is by
          * construction load-bearing — the declaration would be pointless otherwise
-         * — so removing the entry both discards a deliberate recompute trigger and
-         * strands the declaration. The consumer runs `no-unused-vars` as an error
-         * and builds with `noUnusedLocals`, so the rewrite turns a green file red
-         * on their machine while staying green here. Every sibling instance of this
-         * class was fixed by deleting the stranded declaration too, but that remedy
-         * is unavailable here: the declaration is a hook CALL, and dropping it
-         * changes the component's hook order. Declining the edit is the only safe
-         * remedy, so the report stands and the autofix steps aside.
+         * — so removing any one entry discards a deliberate recompute trigger, and
+         * removing all of them strands the declaration. The consumer runs
+         * `no-unused-vars` as an error and builds with `noUnusedLocals`, so the
+         * rewrite turns a green file red on their machine while staying green here.
+         * Every sibling instance of this class was fixed by deleting the stranded
+         * declaration too, but that remedy is unavailable here: the declaration is
+         * a hook CALL, and dropping it changes the component's hook order.
+         * Declining the edit is the only safe remedy, so the report stands and the
+         * autofix steps aside.
+         *
+         * The verdict deliberately ignores which entry is under repair. A test
+         * scoped to one report's own range calls a sibling array's entry a
+         * survivor, and when two hooks list the same unread dependency both reports
+         * reach that conclusion, both fixes apply in one pass, and the binding is
+         * stranded after all (#2210). Discounting every entry instead gates on a
+         * property this fixer owns: no other fixer can manufacture a
+         * non-dependency read, so no sibling edit can move the answer. The
+         * inference is safe in the conservative direction — if a sibling report is
+         * suppressed the cost is a withheld fix, never a dangling reference.
          *
          * Parameters are deliberately exempt. An unread parameter is not an unused
          * BINDING to either instrument — `no-unused-vars` runs with `args: 'none'`
@@ -1308,16 +1352,12 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
             if (variable.defs.some((def) => def.type === 'Parameter')) {
                 return false;
             }
-            const [start, end] = element.range;
+            const entries = collectDependencyEntryIdentifiers();
             // why: a declarator's own initializer counts as a WRITE reference, so a
             // survivor test that accepts any reference never fires for `const x = …`
             // — the shape this check exists for (#1868 is the same trap).
-            return !variable.references.some((reference) => {
-                if (!reference.isRead())
-                    return false;
-                const [from, to] = reference.identifier.range;
-                return from < start || to > end;
-            });
+            return !variable.references.some((reference) => reference.isRead() &&
+                !entries.has(reference.identifier));
         }
         // why: scanning every comment once per file rather than once per hook call
         // keeps the check off the hot path of files with many hooks.

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.192",
+    "date": "2026-08-30T01:20:08.891Z",
+    "rules": [
+      {
+        "name": "enforce-typescript-markdown-code-blocks",
+        "changeType": "fix",
+        "issues": [
+          2213
+        ],
+        "summary": "never write inside a declined block (closes #2213)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.191",
+    "date": "2026-08-29T19:38:08.123Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          2210
+        ],
+        "summary": "discount every dependency entry from the strand check (closes #2210)"
+      }
+    ]
+  },
   {
     "version": "1.20.190",
     "date": "2026-08-29T13:41:20.482Z",