@blumintinc/eslint-plugin-blumint 1.20.24 → 1.20.26

package/lib/index.js

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

package/lib/rules/enforce-assert-safe-object-key.js

@@ -8,6 +8,7 @@ const path_1 = __importDefault(require("path"));
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const disableDirectives_1 = require("../utils/disableDirectives");
 const DEFAULT_IMPORT_PATH = 'functions/src/util/assertSafe';
 exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
     name: 'enforce-assert-safe-object-key',
@@ -35,6 +36,13 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
     create(context, [options]) {
         const importPath = options?.assertSafeImportPath || DEFAULT_IMPORT_PATH;
         let hasAssertSafeImport = false;
+        /**
+         * The `import { assertSafe }` statement rides on a single violation's fix,
+         * making that violation the file's import carrier. A suppressed carrier
+         * would take the import down with it while the surviving violations still
+         * emit `assertSafe(...)`, leaving the call unbound.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         /**
          * Computes the module specifier for the injected assertSafe import.
          *
@@ -97,11 +105,20 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             fixes.push(fixer.replaceText(node, `assertSafe(${argText})`));
             return fixes;
         };
+        // 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.
         const reportUseAssertSafe = (node, expressionText) => context.report({
             node,
             messageId: 'useAssertSafe',
             data: { key: expressionText },
             fix(fixer) {
+                // A suppressed report is dropped together with its fix. Producing no
+                // fix — and leaving the import unclaimed — passes the carrier slot to
+                // the first violation that survives.
+                if (isReportSuppressed(node)) {
+                    return null;
+                }
                 return createFixes(fixer, node, expressionText);
             },
         });

package/lib/rules/enforce-memoize-async.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMemoizeAsync = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 const MEMOIZE_MODULE = '@blumintinc/typescript-memoize';
 const ALLOWED_MEMOIZE_MODULES = new Set([MEMOIZE_MODULE, 'typescript-memoize']);
 /**
@@ -54,6 +55,13 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
         const memoizeAliases = new Map(); // alias -> source module
         const memoizeNamespaces = new Map(); // namespace -> source module
         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);
         return {
             ImportDeclaration(node) {
                 if (ALLOWED_MEMOIZE_MODULES.has(String(node.source.value))) {
@@ -119,10 +127,19 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (hasDecorator) {
                     return;
                 }
+                // 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: 'requireMemoize',
                     fix(fixer) {
+                        // A suppressed report is dropped together with its fix. Producing
+                        // no fix — and leaving the import unscheduled — passes the import
+                        // to the first violation that survives.
+                        if (isReportSuppressed(node)) {
+                            return null;
+                        }
                         const fixes = [];
                         const sourceCode = context.sourceCode;
                         // Determine which identifier to use for the decorator
@@ -135,13 +152,13 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                             }
                             else if (memoizeAliases.size > 0) {
                                 // Find first alias from new package, fallback to any alias
-                                const newPackageAlias = Array.from(memoizeAliases.entries()).find(([_, pkg]) => pkg === MEMOIZE_MODULE)?.[0];
+                                const newPackageAlias = Array.from(memoizeAliases.entries()).find(([, pkg]) => pkg === MEMOIZE_MODULE)?.[0];
                                 decoratorIdent =
                                     newPackageAlias || Array.from(memoizeAliases.keys())[0];
                             }
                             else if (memoizeNamespaces.size > 0) {
                                 // Prefer namespace from the new package if available
-                                const newPackageNs = Array.from(memoizeNamespaces.entries()).find(([_, pkg]) => pkg === MEMOIZE_MODULE)?.[0];
+                                const newPackageNs = Array.from(memoizeNamespaces.entries()).find(([, pkg]) => pkg === MEMOIZE_MODULE)?.[0];
                                 const selectedNs = newPackageNs || Array.from(memoizeNamespaces.keys())[0];
                                 decoratorIdent = `${selectedNs}.Memoize`;
                             }

package/lib/rules/enforce-memoize-getters.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMemoizeGetters = 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,
@@ -58,6 +59,13 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
         let memoizeNamespace = null;
         let hasNamedImport = false;
         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);
         return {
             ImportDeclaration(node) {
                 if (MEMOIZE_MODULES.has(String(node.source.value))) {
@@ -94,11 +102,20 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                 const propertyName = node.computed
                     ? '[computed]'
                     : sourceCode.getText(node.key);
+                // 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: 'requireMemoizeGetter',
                     data: { name: propertyName },
                     fix(fixer) {
+                        // A suppressed report is dropped together with its fix. Producing
+                        // no fix — and leaving the import unscheduled — passes the import
+                        // to the first violation that survives.
+                        if (isReportSuppressed(node)) {
+                            return null;
+                        }
                         const fixes = [];
                         const getDecoratorIdent = () => {
                             if (hasNamedImport) {

package/lib/rules/enforce-querykey-ts.js

@@ -7,6 +7,7 @@ exports.enforceQueryKeyTs = void 0;
 const path_1 = __importDefault(require("path"));
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 // The module's path below the project root doubles as the bare specifier,
 // which is precisely why the root tsconfig `paths` and the Jest mapper resolve
 // it.
@@ -97,6 +98,17 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
          * per-violation insertions that overlap and get dropped.
          */
         const pendingReports = [];
+        /**
+         * The queryKeys import rides on one violation's fix, which makes that
+         * violation the file's import carrier. ESLint collects fixes before it
+         * applies inline disable directives, so a suppressed carrier takes the
+         * import down with it while the surviving substitutions still land —
+         * leaving the file referencing constants nothing imports (#1410).
+         * Resolving suppression here keeps a suppressed violation out of the plan
+         * entirely: it neither claims the carrier slot nor contributes a specifier
+         * to the import, which would otherwise be imported and never used.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         /**
          * `SourceCode#getScope` supersedes the deprecated `context.getScope`; the
          * fallback keeps the rule working on ESLint versions that predate it.
@@ -246,8 +258,11 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             const resolutions = new Map();
             const missingConstants = [];
             const canImport = importSourceOf() !== null;
+            // The location handed to `context.report` below is what ESLint matches a
+            // directive against, so suppression is resolved from exactly that node.
+            const suppressed = new Set(pendingReports.filter((report) => isReportSuppressed(report.node)));
             for (const report of pendingReports) {
-                if (!report.substitution) {
+                if (!report.substitution || suppressed.has(report)) {
                     continue;
                 }
                 const { constant, scope } = report.substitution;
@@ -267,10 +282,16 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             // The first applied substitution carries the import for every other one:
             // its fix range then starts at the top of the file and ends before the
             // remaining literals, so no two fixes of this rule overlap in a pass.
+            // Suppressed reports are skipped so the slot falls to a survivor.
             const importCarrier = pendingReports.find((report) => {
                 const resolution = resolutions.get(report);
-                return resolution !== undefined && resolution.state !== 'conflict';
+                return (!suppressed.has(report) &&
+                    resolution !== undefined &&
+                    resolution.state !== 'conflict');
             });
+            // Suppressed violations are still reported: ESLint discards them, and
+            // reporting keeps the user's directive "used" so that
+            // `--report-unused-disable-directives` does not flag it.
             for (const report of pendingReports) {
                 context.report({
                     node: report.node,
@@ -279,7 +300,8 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                     fix(fixer) {
                         const { substitution } = report;
                         const resolution = resolutions.get(report);
-                        if (!substitution ||
+                        if (suppressed.has(report) ||
+                            !substitution ||
                             !resolution ||
                             resolution.state === 'conflict') {
                             return null;

package/lib/rules/enforce-stable-hash-spread-props.js

@@ -4,6 +4,7 @@ exports.enforceStableHashSpreadProps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 const DEFAULT_HASH_IMPORT = {
     source: 'functions/src/util/hash/stableHash',
     importName: 'stableHash',
@@ -215,7 +216,12 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
             ...(options.allowedHashFunctions ?? []),
         ]);
         const hookNames = new Set([...DEFAULT_HOOKS, ...userHookNames]);
+        // The `import { stableHash }` 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 `stableHash(...)`, leaving calls to an unbound identifier.
         let importPlanned = false;
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         const hashIdentifier = existingHashLocalNames[0] ?? hashImport.importName;
         const functionStack = [];
         function getCurrentComponentContext() {
@@ -294,11 +300,21 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
                 if (offendingElements.length === 0)
                     return;
                 const offendingNames = Array.from(new Set(offendingElements.map(({ name }) => name)));
+                // 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: depsArg,
                     messageId: 'wrapSpreadPropsWithStableHash',
                     data: { names: offendingNames.join(', ') },
                     fix(fixer) {
+                        // A suppressed report is dropped together with its fix. Producing
+                        // no fix — and leaving the import unscheduled — passes the import
+                        // to the first violation that survives. The check runs on the
+                        // reported node so it resolves the same location ESLint does.
+                        if (isReportSuppressed(depsArg)) {
+                            return null;
+                        }
                         const fixes = [];
                         const seen = new Set();
                         for (const { node: targetNode } of offendingElements) {

package/lib/rules/fast-deep-equal-over-microdiff.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fastDeepEqualOverMicrodiff = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
     name: 'fast-deep-equal-over-microdiff',
     meta: {
@@ -31,6 +32,13 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
         let fastDeepEqualImportName = 'isEqual';
         const reportedNodes = new Set();
         let plannedFastDeepEqualImport = false;
+        /**
+         * The `import ... from 'fast-deep-equal'` 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 `isEqual(...)` calls, leaving them unbound.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         const isChainExpression = (node) => node.type === utils_1.AST_NODE_TYPES.ChainExpression;
         function isMicrodiffCallee(callee) {
             if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -292,6 +300,12 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
          * Create a fix for replacing microdiff equality check with fast-deep-equal
          */
         function createFix(fixer, node, diffCall, isEquality) {
+            // A suppressed report is dropped together with its fix. Producing no fix
+            // — and leaving the import unscheduled — passes the carrier slot to the
+            // first violation that survives.
+            if (isReportSuppressed(node)) {
+                return null;
+            }
             const args = diffCall.arguments;
             if (args.length !== 2) {
                 return null; // Can't fix if not exactly 2 arguments