@blumintinc/eslint-plugin-blumint 1.13.0 → 1.14.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

@@ -396,7 +396,7 @@ 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: [],
     },
@@ -412,13 +412,18 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
                     // Check if this could benefit from nullish coalescing
                     // We only suggest nullish coalescing when the left operand could be nullish
                     if (couldBeNullish(node.left)) {
+                        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}`);
                         },