@blumintinc/eslint-plugin-blumint 1.13.0 → 1.14.0

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

@@ -34,7 +34,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
          * Helper function to add assertSafe import if needed
          */
         const addAssertSafeImport = (fixer) => {
-            const program = context.getSourceCode().ast;
+            const program = context.sourceCode.ast;
             const firstImport = program.body.find((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
             const importStatement = `import { assertSafe } from '${importPath}';\n`;
             if (firstImport) {
@@ -83,7 +83,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         key.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         key.callee.name === 'String') {
                         const arg = key.arguments[0];
-                        const argText = context.getSourceCode().getText(arg);
+                        const argText = context.sourceCode.getText(arg);
                         reportUseAssertSafe(key, argText);
                     }
                     // Check for template literals like `${id}`
@@ -93,7 +93,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         key.quasis[0].value.raw === '' &&
                         key.quasis[1].value.raw === '') {
                         const expr = key.expressions[0];
-                        const exprText = context.getSourceCode().getText(expr);
+                        const exprText = context.sourceCode.getText(expr);
                         reportUseAssertSafe(key, exprText);
                     }
                 }
@@ -107,7 +107,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         left.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         left.callee.name === 'String') {
                         const arg = left.arguments[0];
-                        const argText = context.getSourceCode().getText(arg);
+                        const argText = context.sourceCode.getText(arg);
                         reportUseAssertSafe(left, argText);
                     }
                     // Check for template literals like `${id}`
@@ -117,7 +117,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         left.quasis[0].value.raw === '' &&
                         left.quasis[1].value.raw === '') {
                         const expr = left.expressions[0];
-                        const exprText = context.getSourceCode().getText(expr);
+                        const exprText = context.sourceCode.getText(expr);
                         reportUseAssertSafe(left, exprText);
                     }
                 }
@@ -158,7 +158,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         property.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                         property.callee.name === 'String') {
                         const arg = property.arguments[0];
-                        const argText = context.getSourceCode().getText(arg);
+                        const argText = context.sourceCode.getText(arg);
                         reportUseAssertSafe(property, argText);
                         return;
                     }
@@ -179,7 +179,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                             return;
                         }
                         const expr = property.expressions[0];
-                        const exprText = context.getSourceCode().getText(expr);
+                        const exprText = context.sourceCode.getText(expr);
                         reportUseAssertSafe(property, exprText);
                         return;
                     }
@@ -193,7 +193,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        const propText = context.getSourceCode().getText(property);
+                        const propText = context.sourceCode.getText(property);
                         reportUseAssertSafe(property, propText);
                         return;
                     }
@@ -203,7 +203,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        const propText = context.getSourceCode().getText(property);
+                        const propText = context.sourceCode.getText(property);
                         reportUseAssertSafe(property, propText);
                         return;
                     }
@@ -215,7 +215,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        const propText = context.getSourceCode().getText(property);
+                        const propText = context.sourceCode.getText(property);
                         reportUseAssertSafe(property, propText);
                         return;
                     }
@@ -228,7 +228,7 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
-                        const propText = context.getSourceCode().getText(property);
+                        const propText = context.sourceCode.getText(property);
                         reportUseAssertSafe(property, propText);
                         return;
                     }

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -34,6 +34,7 @@ const DEFAULT_OPTIONS = {
     prefixes: DEFAULT_BOOLEAN_PREFIXES,
     ignoreOverriddenGetters: false,
 };
+const BOOLEANISH_BINARY_OPERATORS = new Set(['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof']);
 exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
     name: 'enforce-boolean-naming-prefixes',
     meta: {
@@ -62,15 +63,16 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            missingBooleanPrefix: 'Boolean {{type}} "{{name}}" should start with a prefix like "is", "has", "can", or "should" (e.g., is{{capitalizedName}}, has{{capitalizedName}}). ' +
-                'Boolean prefixes make code self-documenting—readers immediately know the value is true/false without checking its declaration or type. ' +
-                'This improves readability at call sites: `if (user.{{name}})` is ambiguous, but `if (user.is{{capitalizedName}})` clearly signals a boolean check.',
+            missingBooleanPrefix: 'Boolean {{type}} "{{name}}" is missing a common approved boolean prefix ({{prefixes}}). ' +
+                'Prefixes immediately communicate that the value is a true/false predicate; without one, checks like `if ({{name}})` read as generic truthiness guards and hide the boolean intent. ' +
+                'Rename by prepending any approved prefix so the name becomes `<prefix>{{capitalizedName}}`, making the boolean contract obvious at call sites and API boundaries.',
         },
     },
     defaultOptions: [DEFAULT_OPTIONS],
     create(context, [options]) {
         const approvedPrefixes = options.prefixes || DEFAULT_OPTIONS.prefixes;
-        const ignoreOverriddenGetters = options.ignoreOverriddenGetters ?? DEFAULT_OPTIONS.ignoreOverriddenGetters;
+        const ignoreOverriddenGetters = options.ignoreOverriddenGetters ??
+            DEFAULT_OPTIONS.ignoreOverriddenGetters;
         const importStatusCache = new Map();
         const externalApiUsageCache = new Map();
         function findVariableInScopes(name) {
@@ -127,8 +129,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             ];
             return (hasApprovedPrefix(normalizedName, {
                 treatLeadingUnderscoreAsApproved: false,
-            }) ||
-                suffixKeywords.some((keyword) => lowerName.endsWith(keyword)));
+            }) || suffixKeywords.some((keyword) => lowerName.endsWith(keyword)));
         }
         /**
          * Capitalize the first letter of a name for use in suggested alternatives
@@ -200,7 +201,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 }
                 // Check for logical expressions that typically return boolean
                 if (node.init.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
-                    ['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof'].includes(node.init.operator)) {
+                    BOOLEANISH_BINARY_OPERATORS.has(node.init.operator)) {
                     return true;
                 }
                 // Check for logical expressions (&&)
@@ -377,7 +378,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     return true;
                 }
                 if (node.body.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
-                    ['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof'].includes(node.body.operator)) {
+                    BOOLEANISH_BINARY_OPERATORS.has(node.body.operator)) {
                     return true;
                 }
                 if (node.body.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
@@ -434,9 +435,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 const calleeName = callExpression.callee.name;
                 const lowerCallee = calleeName.toLowerCase();
                 if (lowerCallee.startsWith('assert')) {
-                    return identifierReturnsBoolean(calleeName)
-                        ? 'boolean'
-                        : 'unknown';
+                    return identifierReturnsBoolean(calleeName) ? 'boolean' : 'unknown';
                 }
                 const matchesPrefix = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
                     lowerCallee.startsWith(prefix.toLowerCase()));
@@ -516,18 +515,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 return callExpressionLooksBoolean(currentExpression);
             }
             if (currentExpression.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
-                if ([
-                    '===',
-                    '!==',
-                    '==',
-                    '!=',
-                    '>',
-                    '<',
-                    '>=',
-                    '<=',
-                    'in',
-                    'instanceof',
-                ].includes(currentExpression.operator)) {
+                if (BOOLEANISH_BINARY_OPERATORS.has(currentExpression.operator)) {
                     return 'boolean';
                 }
             }

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

@@ -90,7 +90,7 @@ exports.default = (0, createRule_1.createRule)({
             return [];
         }
         function referencesParentScopeVariables(functionNode, parentParams) {
-            const scopeManager = context.getSourceCode().scopeManager;
+            const scopeManager = context.sourceCode.scopeManager;
             if (!scopeManager)
                 return false;
             const scope = scopeManager.acquire(functionNode);

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -140,7 +140,7 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
             },
             'Program:exit'() {
                 if (mockFirestoreNodes.size > 0) {
-                    const sourceCode = context.getSourceCode();
+                    const sourceCode = context.sourceCode;
                     // Report only once for the entire file
                     context.report({
                         node: Array.from(mockFirestoreNodes)[0],

package/lib/rules/enforce-console-error.js

@@ -8,13 +8,13 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce proper logging for useAlertDialog based on severity. When severity is "error", console.error must be included. When severity is "warning", console.warn must be included. This ensures all user-facing errors and warnings are properly logged to monitoring systems.',
+            description: 'Enforce proper logging for useAlertDialog based on severity. When severity is "error", console.error must be included. When severity is "warning", console.warn must be included. This ensures all user-facing errors and warnings are properly logged to observability systems.',
             recommended: 'error',
         },
         messages: {
-            missingConsoleError: 'useAlertDialog with severity "error" requires a console.error statement in the same function scope for proper monitoring.',
-            missingConsoleWarn: 'useAlertDialog with severity "warning" requires a console.warn statement in the same function scope for proper monitoring.',
-            missingConsoleBoth: 'useAlertDialog with dynamic severity requires both console.error and console.warn statements in the same function scope for proper monitoring.',
+            missingConsoleError: 'useAlertDialog call with severity "{{severity}}" shows an error dialog but this function never logs with {{consoleMethod}}. Without the log the alert is invisible to observability and post-incident breadcrumbs. Add a {{consoleMethod}} call in this function scope before or after the open() call so the dialog is paired with an observable error trail.',
+            missingConsoleWarn: 'useAlertDialog call with severity "{{severity}}" shows a warning dialog but this function never logs with {{consoleMethod}}. Without the log the warning is invisible to observability, making degraded states hard to diagnose. Add a {{consoleMethod}} call in this function scope before or after the open() call so the dialog is paired with an observable warning trail.',
+            missingConsoleBoth: 'useAlertDialog call uses dynamic severity, so runtime may render an error or a warning dialog. It is missing {{missingMethods}} in this function scope, leaving one or more runtime severity branches (error or warning) without observability breadcrumbs: {{missingPaths}}. Branch on the severity value and add the matching console method before or after the open() call (console.error for error branches, console.warn for warning branches), as in the conditional pattern shown in the rule docs, so each branch leaves a single appropriate log trail instead of double-logging both methods.',
         },
         schema: [],
     },
@@ -145,13 +145,33 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                     const needsConsoleError = hasError || hasDynamic;
                     const needsConsoleWarn = hasWarning || hasDynamic;
                     if (hasDynamic && (!hasConsoleError || !hasConsoleWarn)) {
-                        const dynamicCall = group.openCalls.find((call) => call.severity === 'dynamic');
-                        if (dynamicCall) {
+                        const missingMethods = [];
+                        const missingSeverities = [];
+                        if (!hasConsoleError) {
+                            missingMethods.push('console.error');
+                            missingSeverities.push('error');
+                        }
+                        if (!hasConsoleWarn) {
+                            missingMethods.push('console.warn');
+                            missingSeverities.push('warning');
+                        }
+                        const missingMethodsLabel = missingMethods.length === 2
+                            ? 'console.error and console.warn'
+                            : missingMethods[0];
+                        const missingPathsLabel = missingSeverities.length === 2
+                            ? 'the error and warning severity paths'
+                            : `the ${missingSeverities[0]} severity path`;
+                        const dynamicCalls = group.openCalls.filter((call) => call.severity === 'dynamic');
+                        dynamicCalls.forEach((dynamicCall) => {
                             context.report({
                                 node: dynamicCall.node,
                                 messageId: 'missingConsoleBoth',
+                                data: {
+                                    missingMethods: missingMethodsLabel,
+                                    missingPaths: missingPathsLabel,
+                                },
                             });
-                        }
+                        });
                     }
                     else {
                         if (needsConsoleError && !hasConsoleError) {
@@ -160,6 +180,10 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                                 context.report({
                                     node: errorCall.node,
                                     messageId: 'missingConsoleError',
+                                    data: {
+                                        severity: 'error',
+                                        consoleMethod: 'console.error',
+                                    },
                                 });
                             }
                         }
@@ -169,6 +193,10 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                                 context.report({
                                     node: warningCall.node,
                                     messageId: 'missingConsoleWarn',
+                                    data: {
+                                        severity: 'warning',
+                                        consoleMethod: 'console.warn',
+                                    },
                                 });
                             }
                         }

package/lib/rules/enforce-dynamic-file-naming.d.ts

@@ -1,3 +1,5 @@
 export declare const RULE_NAME = "enforce-dynamic-file-naming";
+export declare const REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE = "@blumintinc/blumint/require-dynamic-firebase-imports";
+export declare const DYNAMIC_RULES_LABEL: string;
 declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireDynamicExtension" | "requireDisableDirective", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export default _default;

package/lib/rules/enforce-dynamic-file-naming.js

@@ -3,76 +3,101 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RULE_NAME = void 0;
-const createRule_1 = require("../utils/createRule");
+exports.DYNAMIC_RULES_LABEL = exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE = exports.RULE_NAME = void 0;
 const path_1 = __importDefault(require("path"));
+const createRule_1 = require("../utils/createRule");
 exports.RULE_NAME = 'enforce-dynamic-file-naming';
+const ENFORCE_DYNAMIC_IMPORTS_RULE = '@blumintinc/blumint/enforce-dynamic-imports';
+exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE = '@blumintinc/blumint/require-dynamic-firebase-imports';
+exports.DYNAMIC_RULES_LABEL = `${ENFORCE_DYNAMIC_IMPORTS_RULE} or ${exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE}`;
+const SHORTHAND_DISABLE_NEXT_LINE = /\bednl\b/;
+const SHORTHAND_DISABLE_LINE = /\bedl\b/;
+const DISABLE_NEXT_LINE_TOKEN = 'eslint-disable-next-line';
+const DISABLE_LINE_TOKEN = 'eslint-disable-line';
+const DISABLE_BLOCK_PATTERN = /\beslint-disable\b(?!-)/;
+const disabledRuleNameFrom = (commentText) => {
+    const mentionsEnforceDynamicImports = commentText.includes(ENFORCE_DYNAMIC_IMPORTS_RULE);
+    const mentionsRequireDynamicFirebaseImports = commentText.includes(exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE);
+    if (mentionsEnforceDynamicImports && mentionsRequireDynamicFirebaseImports) {
+        return exports.DYNAMIC_RULES_LABEL;
+    }
+    if (mentionsEnforceDynamicImports) {
+        return ENFORCE_DYNAMIC_IMPORTS_RULE;
+    }
+    if (mentionsRequireDynamicFirebaseImports) {
+        return exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE;
+    }
+    return null;
+};
 exports.default = (0, createRule_1.createRule)({
     name: exports.RULE_NAME,
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce .dynamic.ts(x) file naming when @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports rule is disabled',
+            description: `Enforce .dynamic.ts(x) file naming when ${exports.DYNAMIC_RULES_LABEL} rule is disabled`,
             recommended: 'error',
         },
         schema: [],
         messages: {
-            requireDynamicExtension: 'Files with disabled @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports rule must use .dynamic.ts(x) extension',
-            requireDisableDirective: 'Files with .dynamic.ts(x) extension must have at least one @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports disable directive',
+            requireDynamicExtension: 'File "{{fileName}}" disables "{{ruleName}}" but keeps the standard {{extension}} extension, hiding that dynamic-import safeguards are bypassed. Rename to "{{suggestedName}}" (or another *.dynamic.ts/tsx name) so the exception is visible and static-import hotspots stay easy to audit.',
+            requireDisableDirective: 'File "{{fileName}}" uses the ".dynamic" suffix that signals dynamic-import rules are disabled, but it lacks a disable directive for {{dynamicRulesLabel}}. Add the matching disable comment for the static import you need, or rename the file to "{{standardName}}" so the rules keep protecting other files.',
         },
     },
     defaultOptions: [],
     create(context) {
-        // Get the file path and name
         const filePath = context.getFilename();
         const fileName = path_1.default.basename(filePath);
-        // Check if the file is a TypeScript file (ends with .ts or .tsx)
-        // Ignore files with other extensions like .test.ts, .deprecated.ts, etc.
-        const isTypeScriptFile = /^[^.]+\.tsx?$/.test(fileName);
-        // Check if the file has .dynamic.ts or .dynamic.tsx extension
+        const isTypeScriptFile = fileName.endsWith('.ts') || fileName.endsWith('.tsx');
         const hasDynamicExtension = /\.dynamic\.tsx?$/.test(fileName);
-        // Skip if not a TypeScript file or has other extensions
         if (!isTypeScriptFile && !hasDynamicExtension) {
             return {};
         }
-        // Track if we found a disable directive for enforce-dynamic-imports
         let foundDisableDirective = false;
+        let disabledRuleName = null;
         return {
             Program() {
-                // Get the source code
                 const sourceCode = context.getSourceCode();
                 const comments = sourceCode.getAllComments();
-                // Check all comments for disable directives
                 for (const comment of comments) {
                     const commentText = comment.value.trim();
-                    // Check for inline disable directive for either rule
-                    if ((commentText.includes('eslint-disable-next-line') ||
-                        commentText.includes('ednl')) &&
-                        (commentText.includes('@blumintinc/blumint/enforce-dynamic-imports') ||
-                            commentText.includes('@blumintinc/blumint/require-dynamic-firebase-imports'))) {
-                        foundDisableDirective = true;
-                        break;
-                    }
-                    // Check for block disable directive for either rule
-                    if (commentText.includes('eslint-disable ') &&
-                        (commentText.includes('@blumintinc/blumint/enforce-dynamic-imports') ||
-                            commentText.includes('@blumintinc/blumint/require-dynamic-firebase-imports'))) {
+                    const disabledRuleNameForComment = disabledRuleNameFrom(commentText);
+                    const disablesTargetRule = disabledRuleNameForComment !== null;
+                    const inlineDisable = (commentText.includes(DISABLE_NEXT_LINE_TOKEN) ||
+                        commentText.includes(DISABLE_LINE_TOKEN) ||
+                        SHORTHAND_DISABLE_NEXT_LINE.test(commentText) ||
+                        SHORTHAND_DISABLE_LINE.test(commentText)) &&
+                        disablesTargetRule;
+                    const blockDisable = DISABLE_BLOCK_PATTERN.test(commentText) && disablesTargetRule;
+                    if (inlineDisable || blockDisable) {
                         foundDisableDirective = true;
+                        disabledRuleName = disabledRuleNameForComment;
                         break;
                     }
                 }
-                // If we found a disable directive but the file doesn't have .dynamic extension
                 if (foundDisableDirective && !hasDynamicExtension) {
+                    const suggestedName = fileName.replace(/\.tsx?$/, '.dynamic$&');
+                    const extension = path_1.default.extname(fileName);
                     context.report({
                         loc: { line: 1, column: 0 },
                         messageId: 'requireDynamicExtension',
+                        data: {
+                            fileName,
+                            ruleName: disabledRuleName ?? exports.DYNAMIC_RULES_LABEL,
+                            extension,
+                            suggestedName,
+                        },
                     });
                 }
-                // If the file has .dynamic extension but no disable directive
                 if (hasDynamicExtension && !foundDisableDirective) {
+                    const standardName = fileName.replace(/\.dynamic(?=\.tsx?$)/, '');
                     context.report({
                         loc: { line: 1, column: 0 },
                         messageId: 'requireDisableDirective',
+                        data: {
+                            fileName,
+                            standardName,
+                            dynamicRulesLabel: exports.DYNAMIC_RULES_LABEL,
+                        },
                     });
                 }
             },

package/lib/rules/enforce-early-destructuring.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceEarlyDestructuring: TSESLint.RuleModule<"hoistDestructuring", [], TSESLint.RuleListener>;