@blumintinc/eslint-plugin-blumint 1.20.24 → 1.20.26

package/lib/rules/require-memoize-jsx-returners.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireMemoizeJsxReturners = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 const MEMOIZE_PREFERRED_MODULE = '@blumintinc/typescript-memoize';
 const MEMOIZE_MODULES = new Set([
     MEMOIZE_PREFERRED_MODULE,
@@ -384,6 +385,13 @@ exports.requireMemoizeJsxReturners = (0, createRule_1.createRule)({
         let memoizeAlias = 'Memoize';
         let memoizeNamespace = null;
         let scheduledImportFix = false;
+        /**
+         * The `import { Memoize }` statement rides on a single violation's fix, so
+         * that violation is the file's import carrier. A suppressed carrier would
+         * take the import down with it while the surviving violations still emit
+         * `@Memoize()`, leaving a decorator with no import.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         const jsxReturnCache = new WeakMap();
         const reactMemoIdentifiers = new Set();
         const reactNamespaceIdentifiers = new Set();
@@ -454,11 +462,20 @@ exports.requireMemoizeJsxReturners = (0, createRule_1.createRule)({
                 const decoratorIdent = memoizeNamespace
                     ? `${memoizeNamespace}.Memoize`
                     : memoizeAlias;
+                // The report is emitted even when suppressed: ESLint discards it, and
+                // reporting keeps the user's disable directive "used" so that
+                // `--report-unused-disable-directives` does not flag it.
                 context.report({
                     node,
                     messageId: 'requireMemoizeJsxReturner',
                     data: { name: getMemberName(node) },
                     fix(fixer) {
+                        // A suppressed report is dropped together with its fix. Producing
+                        // no fix — and leaving `scheduledImportFix` untouched — passes the
+                        // import to the first violation that survives.
+                        if (isReportSuppressed(node)) {
+                            return null;
+                        }
                         const sourceCode = context.getSourceCode();
                         const { fixes, scheduledImportFix: newScheduledImportFix } = getImportFixes(fixer, sourceCode, hasMemoizeImport, scheduledImportFix);
                         scheduledImportFix = newScheduledImportFix;

package/lib/utils/disableDirectives.d.ts

@@ -0,0 +1,51 @@
+import { TSESLint, TSESTree } from '@typescript-eslint/utils';
+type DirectiveKind = 'disable' | 'enable' | 'disable-line' | 'disable-next-line';
+export type Directive = {
+    kind: DirectiveKind;
+    /** `null` when the directive names no rule, which targets every rule. */
+    rules: Set<string> | null;
+    /**
+     * For block directives, the comment's own position; for line-scoped ones,
+     * the single source line the directive covers.
+     */
+    line: number;
+    column: number;
+};
+/**
+ * Parses every disable/enable directive in a file, ordered by position so the
+ * block-scoped pass can walk them as a timeline.
+ */
+export declare function parseDisableDirectives(comments: readonly TSESTree.Comment[]): Directive[];
+/**
+ * Whether `ruleId` is disabled at `loc` by the already-parsed `directives`.
+ */
+export declare function isSuppressed(directives: readonly Directive[], ruleId: string, loc: TSESTree.Position): boolean;
+/**
+ * Anything a rule already has in hand when it reports: a raw position, or any
+ * node/token/comment carrying a `loc`. Rules reporting on expressions or JSX
+ * elements pass the node as readily as ones reporting on method definitions.
+ */
+export type SuppressionTarget = TSESTree.Position | {
+    readonly loc: TSESTree.SourceLocation;
+};
+export type SuppressionChecker = (target: SuppressionTarget) => boolean;
+/**
+ * Builds a suppression predicate over a fixed set of comments. Exposed for
+ * direct testing and for callers that hold comments rather than a rule context;
+ * rules should prefer {@link createSuppressionChecker}.
+ */
+export declare function createSuppressionCheckerFor(comments: readonly TSESTree.Comment[], ruleId: string): SuppressionChecker;
+/**
+ * Builds a per-file suppression predicate for the rule that owns `context`.
+ * Intended for a rule's `fix()` callback, which must decline to fix a report
+ * ESLint is about to discard.
+ *
+ * The file's comments are parsed once, on first use, and reused for every
+ * subsequent call — a rule asks this per violation.
+ *
+ * `context.id` is exactly the name a disable directive must spell, whether the
+ * rule runs bare (as under `RuleTester`) or under its plugin prefix, so the
+ * match never hardcodes a prefix.
+ */
+export declare function createSuppressionChecker<TMessageIds extends string, TOptions extends readonly unknown[]>(context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>): SuppressionChecker;
+export {};

package/lib/utils/disableDirectives.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSuppressionChecker = exports.createSuppressionCheckerFor = exports.isSuppressed = exports.parseDisableDirectives = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Resolves whether a report location is suppressed by an inline ESLint disable
+ * directive, from inside the rule itself.
+ *
+ * A rule that adds a shared edit — typically an `import` statement — by
+ * attaching it to a single violation's fix makes that violation the file's
+ * import carrier. ESLint calls `fix()` eagerly, while inline disable directives
+ * are applied afterwards: a suppressed report takes its fix down with it. If the
+ * carrier is suppressed, the surviving violations still emit their rewritten
+ * code and the file ends up referencing an identifier that was never imported.
+ * Resolving suppression up front lets the carrier slot fall to the first
+ * violation that actually survives.
+ *
+ * The parsing below mirrors ESLint's own directive handling
+ * (`lib/linter/apply-disable-directives.js`).
+ */
+const DIRECTIVE_PATTERN = /^(eslint-disable(?:-next-line|-line)?|eslint-enable)(?:\s|$)/;
+/** ESLint separates a directive from its justification with ` -- `. */
+const JUSTIFICATION_SEPARATOR = /\s-{2,}\s/;
+function parseDirective(comment) {
+    const justification = JUSTIFICATION_SEPARATOR.exec(comment.value);
+    const directivePart = (justification ? comment.value.slice(0, justification.index) : comment.value).trim();
+    const match = DIRECTIVE_PATTERN.exec(directivePart);
+    if (!match) {
+        return null;
+    }
+    const token = match[1];
+    const kind = token.slice('eslint-'.length);
+    const isLineScoped = kind === 'disable-line' || kind === 'disable-next-line';
+    // `eslint-disable`/`eslint-enable` are honoured only in block comments, and
+    // a multi-line `eslint-disable-line` is rejected outright — both per ESLint.
+    if (!isLineScoped && comment.type !== utils_1.AST_TOKEN_TYPES.Block) {
+        return null;
+    }
+    if (kind === 'disable-line' &&
+        comment.loc.start.line !== comment.loc.end.line) {
+        return null;
+    }
+    const ruleList = directivePart.slice(token.length).trim();
+    const rules = ruleList === ''
+        ? null
+        : new Set(ruleList
+            .split(',')
+            .map((rule) => rule.trim())
+            .filter((rule) => rule !== ''));
+    // A multi-line `eslint-disable-next-line` targets the line after the comment
+    // ends, not after it starts.
+    const line = kind === 'disable-next-line'
+        ? comment.loc.end.line + 1
+        : comment.loc.start.line;
+    return { kind, rules, line, column: comment.loc.start.column };
+}
+/**
+ * Parses every disable/enable directive in a file, ordered by position so the
+ * block-scoped pass can walk them as a timeline.
+ */
+function parseDisableDirectives(comments) {
+    return comments
+        .map(parseDirective)
+        .filter((directive) => directive !== null)
+        .sort((a, b) => a.line - b.line || a.column - b.column);
+}
+exports.parseDisableDirectives = parseDisableDirectives;
+function targetsRule(directive, ruleId) {
+    return directive.rules === null || directive.rules.has(ruleId);
+}
+/**
+ * ESLint evaluates line-scoped directives in a pass of their own, so the
+ * implicit re-enable that follows an `eslint-disable-next-line` cannot punch a
+ * hole in a surrounding block disable. This mirrors that separation.
+ */
+function isBlockSuppressed(directives, ruleId, loc) {
+    let globalDisabled = false;
+    let ruleDisabled = false;
+    // An `eslint-enable <rule>` carves a single rule out of a bare disable.
+    let ruleReEnabled = false;
+    for (const directive of directives) {
+        if (directive.kind !== 'disable' && directive.kind !== 'enable') {
+            continue;
+        }
+        const isBefore = directive.line < loc.line ||
+            (directive.line === loc.line && directive.column <= loc.column);
+        if (!isBefore) {
+            break;
+        }
+        const isBare = directive.rules === null;
+        if (!isBare && !targetsRule(directive, ruleId)) {
+            continue;
+        }
+        if (directive.kind === 'disable') {
+            if (isBare) {
+                globalDisabled = true;
+                ruleDisabled = false;
+                ruleReEnabled = false;
+            }
+            else if (globalDisabled) {
+                ruleReEnabled = false;
+            }
+            else {
+                ruleDisabled = true;
+            }
+            continue;
+        }
+        if (isBare) {
+            globalDisabled = false;
+            ruleDisabled = false;
+            ruleReEnabled = false;
+        }
+        else if (globalDisabled) {
+            ruleReEnabled = true;
+        }
+        else {
+            ruleDisabled = false;
+        }
+    }
+    return ruleDisabled || (globalDisabled && !ruleReEnabled);
+}
+/**
+ * Whether `ruleId` is disabled at `loc` by the already-parsed `directives`.
+ */
+function isSuppressed(directives, ruleId, loc) {
+    const lineSuppressed = directives.some((directive) => (directive.kind === 'disable-line' ||
+        directive.kind === 'disable-next-line') &&
+        directive.line === loc.line &&
+        targetsRule(directive, ruleId));
+    return lineSuppressed || isBlockSuppressed(directives, ruleId, loc);
+}
+exports.isSuppressed = isSuppressed;
+function positionOf(target) {
+    return 'loc' in target ? target.loc.start : target;
+}
+/**
+ * Builds a suppression predicate over a fixed set of comments. Exposed for
+ * direct testing and for callers that hold comments rather than a rule context;
+ * rules should prefer {@link createSuppressionChecker}.
+ */
+function createSuppressionCheckerFor(comments, ruleId) {
+    const directives = parseDisableDirectives(comments);
+    return (target) => isSuppressed(directives, ruleId, positionOf(target));
+}
+exports.createSuppressionCheckerFor = createSuppressionCheckerFor;
+/**
+ * Builds a per-file suppression predicate for the rule that owns `context`.
+ * Intended for a rule's `fix()` callback, which must decline to fix a report
+ * ESLint is about to discard.
+ *
+ * The file's comments are parsed once, on first use, and reused for every
+ * subsequent call — a rule asks this per violation.
+ *
+ * `context.id` is exactly the name a disable directive must spell, whether the
+ * rule runs bare (as under `RuleTester`) or under its plugin prefix, so the
+ * match never hardcodes a prefix.
+ */
+function createSuppressionChecker(context) {
+    let checker = null;
+    return (target) => {
+        if (checker === null) {
+            checker = createSuppressionCheckerFor(context.sourceCode.getAllComments(), context.id);
+        }
+        return checker(target);
+    };
+}
+exports.createSuppressionChecker = createSuppressionChecker;
+//# sourceMappingURL=disableDirectives.js.map

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,129 @@
 [
+  {
+    "version": "1.20.26",
+    "date": "2026-07-30T06:12:23.979Z",
+    "rules": [
+      {
+        "name": "enforce-assert-safe-object-key",
+        "changeType": "fix",
+        "issues": [
+          1408
+        ],
+        "summary": "keep the assertSafe import when the carrier violation is disabled inline (closes #1408)"
+      },
+      {
+        "name": "enforce-memoize-async",
+        "changeType": "fix",
+        "issues": [
+          1404
+        ],
+        "summary": "keep the Memoize import when the carrier violation is disabled (closes #1404)"
+      },
+      {
+        "name": "enforce-memoize-getters",
+        "changeType": "fix",
+        "issues": [
+          1409
+        ],
+        "summary": "keep the Memoize import when the carrier violation is disabled inline (closes #1409)"
+      },
+      {
+        "name": "enforce-querykey-ts",
+        "changeType": "fix",
+        "issues": [
+          1410
+        ],
+        "summary": "exclude suppressed reports from the import plan and carrier choice (closes #1410)"
+      },
+      {
+        "name": "enforce-stable-hash-spread-props",
+        "changeType": "fix",
+        "issues": [
+          1413
+        ],
+        "summary": "keep the stableHash import when the carrier violation is disabled inline (closes #1413)"
+      },
+      {
+        "name": "fast-deep-equal-over-microdiff",
+        "changeType": "fix",
+        "issues": [
+          1415
+        ],
+        "summary": "keep the isEqual import when the carrier violation is disabled inline (closes #1415)"
+      },
+      {
+        "name": "logical-top-to-bottom-grouping",
+        "changeType": "fix",
+        "issues": [
+          1405
+        ],
+        "summary": "emit a fully-satisfying reordering as one fix (closes #1405)"
+      },
+      {
+        "name": "no-array-length-in-deps",
+        "changeType": "fix",
+        "issues": [
+          1412
+        ],
+        "summary": "keep both planned imports when the carrier violation is disabled inline (closes #1412)"
+      },
+      {
+        "name": "prefer-fragment-component",
+        "changeType": "fix",
+        "issues": [
+          1407
+        ],
+        "summary": "keep the Fragment import when the carrier violation is disabled inline (closes #1407)"
+      },
+      {
+        "name": "prefer-type-over-interface",
+        "changeType": "fix",
+        "issues": [
+          1403,
+          1406
+        ],
+        "summary": "join heritage clauses with `&` in the autofix (closes #1406); insert `=` after the type parameters (closes #1403)"
+      },
+      {
+        "name": "prefer-usecallback-over-usememo-for-functions",
+        "changeType": "fix",
+        "issues": [
+          1411
+        ],
+        "summary": "exclude suppressed violations from the conversion plan (closes #1411)"
+      },
+      {
+        "name": "require-memoize-jsx-returners",
+        "changeType": "fix",
+        "issues": [
+          1414
+        ],
+        "summary": "keep the Memoize import when the carrier violation is disabled inline (closes #1414)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.25",
+    "date": "2026-07-30T02:59:17.229Z",
+    "rules": [
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1401
+        ],
+        "summary": "render optional links per segment (closes #1401)"
+      },
+      {
+        "name": "prefer-map-over-conditional-dispatch",
+        "changeType": "fix",
+        "issues": [
+          1402
+        ],
+        "summary": "validate the synthesized Record annotation (closes #1402)"
+      }
+    ]
+  },
   {
     "version": "1.20.24",
     "date": "2026-07-30T02:00:54.523Z",