@blumintinc/eslint-plugin-blumint 1.13.0 → 1.15.0

package/lib/rules/prefer-next-dynamic.js

@@ -12,6 +12,47 @@ const DEFAULT_USE_DYNAMIC_SOURCES = [
 function matchesAllowedSource(source, allowedSources) {
     return allowedSources.some((pattern) => source === pattern || source.endsWith(`/${pattern}`));
 }
+function hasNodeStructure(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'type' in value &&
+        typeof value.type === 'string');
+}
+/**
+ * Walks the AST and invokes the visitor on each node.
+ * Uses WeakSet to prevent infinite cycles.
+ *
+ * @param visitor - Callback invoked on each node. Return `false` to stop
+ * traversal; return `undefined` (or nothing) to continue walking.
+ * @returns `false` if traversal stopped early; `true` when traversal completes.
+ */
+function walkAst(node, visitor, visited = new WeakSet()) {
+    if (visited.has(node))
+        return true;
+    visited.add(node);
+    const shouldContinue = visitor(node);
+    if (shouldContinue === false)
+        return false;
+    const anyNode = node;
+    for (const key of Object.keys(anyNode)) {
+        if (key === 'parent')
+            continue;
+        const child = anyNode[key];
+        if (Array.isArray(child)) {
+            for (const c of child) {
+                if (hasNodeStructure(c)) {
+                    if (!walkAst(c, visitor, visited))
+                        return false;
+                }
+            }
+        }
+        else if (hasNodeStructure(child)) {
+            if (!walkAst(child, visitor, visited))
+                return false;
+        }
+    }
+    return true;
+}
 function isUseDynamicCall(node) {
     const { callee, arguments: args } = node;
     if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -126,7 +167,7 @@ exports.preferNextDynamic = (0, createRule_1.createRule)({
         docs: {
             description: 'Prefer Next.js dynamic() over custom useDynamic() for component imports',
             recommended: 'error',
-            requiresTypeChecking: true,
+            requiresTypeChecking: false,
         },
         fixable: 'code',
         schema: [
@@ -143,9 +184,9 @@ exports.preferNextDynamic = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            preferNextDynamic: 'Use Next.js dynamic() instead of useDynamic(import(...)) for component imports',
-            addNextDynamicImport: "Add default import: import dynamic from 'next/dynamic'",
-            removeUseDynamicImport: 'Remove unused useDynamic import',
+            preferNextDynamic: 'Component "{{componentName}}" is created with useDynamic(import(...)), which bypasses Next.js dynamic() handling for client-only components and leaves SSR control to a custom wrapper. Wrap the import in dynamic(() => import(...), { ssr: false }) so Next.js manages code-splitting and disables server rendering safely.',
+            addNextDynamicImport: "The auto-fix will replace useDynamic(import(...)) with dynamic(() => import(...), { ssr: false }), which references Next.js's dynamic function. Without importing dynamic from 'next/dynamic', the fixed code will throw a ReferenceError at runtime when the module loads. Add `import dynamic from 'next/dynamic'` at the top of the file to make the dynamic identifier available.",
+            removeUseDynamicImport: 'Remove the unused useDynamic import after migrating to dynamic(); leaving the custom hook imported invites accidental reuse and keeps dead code in the bundle.',
         },
     },
     defaultOptions: [{}],
@@ -154,7 +195,7 @@ exports.preferNextDynamic = (0, createRule_1.createRule)({
         const allowedUseDynamicSources = options.useDynamicSources && options.useDynamicSources.length > 0
             ? options.useDynamicSources
             : DEFAULT_USE_DYNAMIC_SOURCES;
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         return {
             VariableDeclarator(node) {
                 const info = inferVariableInfo(node);
@@ -169,50 +210,18 @@ exports.preferNextDynamic = (0, createRule_1.createRule)({
                 if (!useDynamicImportInfo)
                     return;
                 const identifierName = info.idText;
-                let usedInJsx = false;
-                const scopeBody = program.body;
-                // Walk AST to find JSX usage; track visited nodes to avoid cycles
-                // Note: We intentionally avoid relying on tokens here.
-                // Fallback AST traversal for JSX usage
-                const visited = new WeakSet();
-                const checkJsxUsage = (n) => {
-                    if (visited.has(n))
-                        return;
-                    visited.add(n);
-                    if (usedInJsx)
-                        return;
+                // walkAst returns false when visitor returns false (early exit on match)
+                const usedInJsx = program.body.some((b) => walkAst(b, (n) => {
                     if (n.type === utils_1.AST_NODE_TYPES.JSXOpeningElement) {
                         const name = n.name;
                         if (name.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
-                            if (name.name === identifierName)
-                                usedInJsx = true;
-                        }
-                        else if (name.type === utils_1.AST_NODE_TYPES.JSXMemberExpression) {
-                            // Not matching identifier simple usage
-                        }
-                    }
-                    // recurse
-                    const anyNode = n;
-                    for (const key of Object.keys(anyNode)) {
-                        if (key === 'parent')
-                            continue;
-                        const child = anyNode[key];
-                        if (Array.isArray(child)) {
-                            for (const c of child) {
-                                if (c && typeof c.type === 'string') {
-                                    checkJsxUsage(c);
-                                }
-                            }
-                        }
-                        else if (child && typeof child === 'object') {
-                            if (child.type &&
-                                typeof child.type === 'string') {
-                                checkJsxUsage(child);
+                            if (name.name === identifierName) {
+                                return false;
                             }
                         }
                     }
-                };
-                scopeBody.forEach((b) => checkJsxUsage(b));
+                    return undefined;
+                }) === false);
                 if (!usedInJsx) {
                     // Skip to avoid flagging non-component dynamic imports
                     return;
@@ -223,10 +232,11 @@ exports.preferNextDynamic = (0, createRule_1.createRule)({
                 context.report({
                     node: init,
                     messageId: 'preferNextDynamic',
+                    data: { componentName: identifierName },
                     fix(fixer) {
                         const fixes = [];
                         // ensure dynamic import is present
-                        const programNode = findProgramNode(node);
+                        const programNode = program;
                         let dynamicLocal = getNextDynamicLocalName(programNode);
                         const hasDynamic = !!dynamicLocal;
                         if (!hasDynamic) {
@@ -266,33 +276,14 @@ exports.preferNextDynamic = (0, createRule_1.createRule)({
                         const latestUseDynamicImport = findUseDynamicImport(programNode, allowedUseDynamicSources);
                         if (latestUseDynamicImport) {
                             // Abort removal if there are other useDynamic(import(...)) calls in the file
-                            let otherUseDynamicCalls = false;
-                            const visit = (n) => {
-                                if (otherUseDynamicCalls)
-                                    return;
+                            const otherUseDynamicCalls = programNode.body.some((b) => walkAst(b, (n) => {
                                 if (n.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                                    isUseDynamicCall(n)) {
-                                    if (n !== init)
-                                        otherUseDynamicCalls = true;
-                                }
-                                const anyNode = n;
-                                for (const key of Object.keys(anyNode)) {
-                                    if (key === 'parent')
-                                        continue;
-                                    const child = anyNode[key];
-                                    if (Array.isArray(child)) {
-                                        for (const c of child)
-                                            if (c && typeof c.type === 'string')
-                                                visit(c);
-                                    }
-                                    else if (child &&
-                                        typeof child === 'object' &&
-                                        child.type) {
-                                        visit(child);
-                                    }
+                                    isUseDynamicCall(n) &&
+                                    n !== init) {
+                                    return false;
                                 }
-                            };
-                            programNode.body.forEach((b) => visit(b));
+                                return undefined;
+                            }) === false);
                             if (otherUseDynamicCalls) {
                                 return fixes; // keep the import; other occurrences still rely on it
                             }

package/lib/rules/prefer-nullish-coalescing-boolean-props.js

@@ -1,9 +1,73 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferNullishCoalescingBooleanProps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
 const BOOLEAN_PROP_REGEX = /^(is|has|should|can|will|do|does|did|was|were|enable|disable)/;
+function isBooleanType(type, checker) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isBooleanType(t, checker));
+    }
+    // For type parameters, check if the constraint is a boolean type
+    if (type.getFlags() & ts.TypeFlags.TypeParameter) {
+        if (checker) {
+            const constraint = checker.getBaseConstraintOfType(type);
+            if (constraint && constraint !== type) {
+                return isBooleanType(constraint, checker);
+            }
+        }
+        return false;
+    }
+    return ((type.getFlags() & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) !==
+        0);
+}
+function isPossiblyNullish(type, checker) {
+    if (type.isUnion()) {
+        return type.types.some((t) => isPossiblyNullish(t, checker));
+    }
+    // For type parameters, check if the constraint excludes nullish
+    if (type.getFlags() & ts.TypeFlags.TypeParameter) {
+        if (checker) {
+            const constraint = checker.getBaseConstraintOfType(type);
+            if (constraint && constraint !== type) {
+                return isPossiblyNullish(constraint, checker);
+            }
+        }
+        // If we can't determine the constraint, assume it could be nullish
+        return true;
+    }
+    return ((type.getFlags() &
+        (ts.TypeFlags.Null |
+            ts.TypeFlags.Undefined |
+            ts.TypeFlags.Void |
+            ts.TypeFlags.Any |
+            ts.TypeFlags.Unknown)) !==
+        0);
+}
 function isInJSXBooleanAttribute(node) {
     const parent = node.parent;
     if (parent?.type !== utils_1.AST_NODE_TYPES.JSXAttribute)
@@ -57,7 +121,34 @@ function isInConditionalContext(node) {
 /**
  * Determines if a node is within a boolean context in JSX props or other boolean contexts
  */
-function isInBooleanContext(node) {
+function isInBooleanContext(node, checker, parserServices) {
+    if (checker && parserServices) {
+        try {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const contextualType = checker.getContextualType(tsNode);
+            if (contextualType && isBooleanType(contextualType, checker)) {
+                return true;
+            }
+            // Also check if the expression itself is a boolean type
+            const actualType = checker.getTypeAtLocation(tsNode);
+            if (actualType && isBooleanType(actualType, checker)) {
+                return true;
+            }
+            // If this is a logical expression, also check if the left operand is a boolean
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                const leftTSNode = parserServices.esTreeNodeToTSNodeMap.get(node.left);
+                const leftType = checker.getTypeAtLocation(leftTSNode);
+                if (leftType && isBooleanType(leftType, checker)) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // esTreeNodeToTSNodeMap may fail for synthetic nodes or nodes without
+            // source positions; getContextualType may return undefined for non-expression
+            // contexts. Fall back to AST-based heuristics in these cases.
+        }
+    }
     let current = node;
     // Traverse up the AST to find if we're in a boolean context
     while (current && current.parent) {
@@ -365,7 +456,19 @@ function isInBooleanContext(node) {
 /**
  * Checks if the left operand could be nullish (null or undefined)
  */
-function couldBeNullish(node) {
+function couldBeNullish(node, checker, parserServices) {
+    if (checker && parserServices) {
+        try {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return isPossiblyNullish(type, checker);
+        }
+        catch {
+            // esTreeNodeToTSNodeMap may fail for synthetic nodes or nodes without
+            // source positions; getTypeAtLocation may throw for nodes without
+            // type information. Fall back to manual check.
+        }
+    }
     // For literals, check the actual value
     if (node.type === utils_1.AST_NODE_TYPES.Literal) {
         return node.value === null || node.value === undefined;
@@ -396,29 +499,36 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
         },
         fixable: 'code',
         messages: {
-            preferNullishCoalescing: 'Prefer using nullish coalescing operator (??) instead of logical OR operator (||) when checking for null/undefined',
+            preferNullishCoalescing: 'Logical OR between "{{left}}" and "{{right}}" treats every falsy value (false, 0, "", NaN) as missing and will override intentional boolean or empty states. Use the nullish coalescing operator (??) so "{{right}}" only applies when "{{left}}" is null or undefined, preserving explicit false/0/"" values.',
         },
         schema: [],
     },
     defaultOptions: [],
     create(context) {
+        const parserServices = utils_1.ESLintUtils.getParserServices(context, true);
+        const checker = parserServices?.program?.getTypeChecker();
         return {
             LogicalExpression(node) {
                 if (node.operator === '||') {
                     // If the node is in a boolean context, we allow logical OR
-                    if (isInBooleanContext(node)) {
+                    if (isInBooleanContext(node, checker, parserServices)) {
                         return;
                     }
                     // Check if this could benefit from nullish coalescing
                     // We only suggest nullish coalescing when the left operand could be nullish
-                    if (couldBeNullish(node.left)) {
+                    if (couldBeNullish(node.left, checker, parserServices)) {
+                        const sourceCode = context.getSourceCode();
+                        const leftText = sourceCode.getText(node.left);
+                        const rightText = sourceCode.getText(node.right);
                         context.report({
                             node,
                             messageId: 'preferNullishCoalescing',
+                            data: {
+                                left: leftText,
+                                right: rightText,
+                            },
                             fix(fixer) {
-                                return fixer.replaceText(node, `${context.getSourceCode().getText(node.left)} ?? ${context
-                                    .getSourceCode()
-                                    .getText(node.right)}`);
+                                return fixer.replaceText(node, `${leftText} ?? ${rightText}`);
                             },
                         });
                     }

package/lib/rules/prefer-nullish-coalescing-override.d.ts

@@ -1,6 +1,7 @@
+import { TSESLint } from '@typescript-eslint/utils';
 /**
  * This rule overrides the behavior of @typescript-eslint/prefer-nullish-coalescing
  * to only suggest using the nullish coalescing operator when checking for null/undefined,
  * not when intentionally checking for all falsy values.
  */
-export declare const preferNullishCoalescingOverride: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferNullishCoalescing", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const preferNullishCoalescingOverride: TSESLint.RuleModule<"preferNullishCoalescing", [], TSESLint.RuleListener>;

package/lib/rules/prefer-nullish-coalescing-override.js

@@ -19,11 +19,13 @@ exports.preferNullishCoalescingOverride = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            preferNullishCoalescing: 'Prefer using nullish coalescing operator (`??`) instead of logical OR operator (`||`) when only checking for null/undefined.',
+            preferNullishCoalescing: 'Replace "{{left}} || {{right}}" with nullish coalescing when you only want a fallback for null or undefined. The logical OR operator treats "", 0, and false as missing values and silently swaps in the fallback, which hides valid data. Use "{{left}} ?? {{right}}" so only nullish inputs trigger the fallback.',
         },
     },
     defaultOptions: [],
     create(context) {
+        const contextWithSource = context;
+        const sourceCode = contextWithSource.sourceCode ?? contextWithSource.getSourceCode();
         /**
          * Checks if a node is in a boolean context where truthiness matters
          */
@@ -154,7 +156,8 @@ exports.preferNullishCoalescingOverride = (0, createRule_1.createRule)({
         /**
          * Checks if this logical OR should be converted to nullish coalescing
          */
-        function shouldConvertToNullishCoalescing(_node) {
+        function shouldConvertToNullishCoalescing(node) {
+            void node;
             return false;
         }
         void isInBooleanContext;
@@ -164,12 +167,15 @@ exports.preferNullishCoalescingOverride = (0, createRule_1.createRule)({
         return {
             LogicalExpression(node) {
                 if (shouldConvertToNullishCoalescing(node)) {
-                    const sc = context.getSourceCode();
-                    const leftText = sc.getText(node.left);
-                    const rightText = sc.getText(node.right);
+                    const leftText = sourceCode.getText(node.left);
+                    const rightText = sourceCode.getText(node.right);
                     context.report({
                         node,
                         messageId: 'preferNullishCoalescing',
+                        data: {
+                            left: leftText,
+                            right: rightText,
+                        },
                         fix(fixer) {
                             return fixer.replaceText(node, `${leftText} ?? ${rightText}`);
                         },