@blumintinc/eslint-plugin-blumint 1.10.0 → 1.11.0

package/lib/rules/react-usememo-should-be-component.js

@@ -12,6 +12,15 @@ const isJsxElement = (node) => {
     if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
         return isJsxElement(node.consequent) || isJsxElement(node.alternate);
     }
+    // For logical expressions like '&&', the result can be a non-JSX value
+    if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+        // If it's a logical AND (&&), it can return the left operand which might be non-JSX
+        if (node.operator === '&&') {
+            return false;
+        }
+        // For other logical operators, check both sides
+        return isJsxElement(node.left) || isJsxElement(node.right);
+    }
     return (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
         node.type === utils_1.AST_NODE_TYPES.JSXFragment);
 };
@@ -57,7 +66,7 @@ const isUsedMultipleTimes = (variableName, node) => {
             const child = searchNode[key];
             if (child && typeof child === 'object') {
                 if (Array.isArray(child)) {
-                    child.forEach(item => {
+                    child.forEach((item) => {
                         if (item && typeof item === 'object') {
                             findReferences(item);
                         }
@@ -105,7 +114,8 @@ const containsJsxInObject = (node) => {
 const containsJsxInSwitchStatement = (node) => {
     for (const switchCase of node.cases) {
         for (const statement of switchCase.consequent) {
-            if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+            if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                statement.argument) {
                 if (isJsxElement(statement.argument)) {
                     return true;
                 }
@@ -144,8 +154,17 @@ const containsJsxInFunction = (node) => {
         if (body.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
             body.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
             // Check array methods like map, filter, find, etc.
-            const arrayMethods = ['map', 'filter', 'find', 'findIndex', 'some', 'every', 'reduce'];
-            if (arrayMethods.includes(body.callee.property.name) && body.arguments.length > 0) {
+            const arrayMethods = [
+                'map',
+                'filter',
+                'find',
+                'findIndex',
+                'some',
+                'every',
+                'reduce',
+            ];
+            if (arrayMethods.includes(body.callee.property.name) &&
+                body.arguments.length > 0) {
                 const callback = body.arguments[0];
                 if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
                     callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
@@ -183,9 +202,17 @@ const containsJsxInExpression = (node) => {
     }
     switch (node.type) {
         case utils_1.AST_NODE_TYPES.ConditionalExpression:
-            return containsJsxInExpression(node.consequent) || containsJsxInExpression(node.alternate);
+            return (containsJsxInExpression(node.consequent) ||
+                containsJsxInExpression(node.alternate));
         case utils_1.AST_NODE_TYPES.LogicalExpression:
-            return containsJsxInExpression(node.left) || containsJsxInExpression(node.right);
+            // For logical AND (&&) expressions, if the left side can be falsy,
+            // then the expression can return a non-JSX value, so we should not flag it
+            if (node.operator === '&&') {
+                // If the left side is a boolean expression or can be falsy, this can return a non-JSX value
+                return false;
+            }
+            return (containsJsxInExpression(node.left) ||
+                containsJsxInExpression(node.right));
         case utils_1.AST_NODE_TYPES.ObjectExpression:
             // Special case: If this is an object with both JSX and non-JSX properties,
             // it's likely a data structure that happens to contain JSX, not a component
@@ -218,8 +245,8 @@ const containsJsxInExpression = (node) => {
                 node.callee.property.name === 'map' &&
                 node.arguments.length > 0) {
                 const callback = node.arguments[0];
-                if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
                     // Check if the callback returns an object with both JSX and non-JSX properties
                     if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement &&
                         callback.body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
@@ -252,18 +279,27 @@ const containsJsxInExpression = (node) => {
             // Check array methods
             if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                 node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                const arrayMethods = ['filter', 'find', 'findIndex', 'some', 'every', 'reduce'];
-                if (arrayMethods.includes(node.callee.property.name) && node.arguments.length > 0) {
+                const arrayMethods = [
+                    'filter',
+                    'find',
+                    'findIndex',
+                    'some',
+                    'every',
+                    'reduce',
+                ];
+                if (arrayMethods.includes(node.callee.property.name) &&
+                    node.arguments.length > 0) {
                     const callback = node.arguments[0];
-                    if ((callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
                         return containsJsxInFunction(callback);
                     }
                 }
             }
             // Check arguments for JSX
             for (const arg of node.arguments) {
-                if (arg.type !== utils_1.AST_NODE_TYPES.SpreadElement && containsJsxInExpression(arg)) {
+                if (arg.type !== utils_1.AST_NODE_TYPES.SpreadElement &&
+                    containsJsxInExpression(arg)) {
                     return true;
                 }
             }
@@ -281,7 +317,8 @@ const containsJsxInExpression = (node) => {
 const containsJsxInBlockStatement = (node) => {
     for (const statement of node.body) {
         // Check return statements
-        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+            statement.argument) {
             if (containsJsxInExpression(statement.argument)) {
                 return true;
             }
@@ -289,7 +326,8 @@ const containsJsxInBlockStatement = (node) => {
         // Check if statements
         if (statement.type === utils_1.AST_NODE_TYPES.IfStatement) {
             if (statement.consequent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
-                statement.consequent.argument && containsJsxInExpression(statement.consequent.argument)) {
+                statement.consequent.argument &&
+                containsJsxInExpression(statement.consequent.argument)) {
                 return true;
             }
             if (statement.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement &&
@@ -298,7 +336,8 @@ const containsJsxInBlockStatement = (node) => {
             }
             if (statement.alternate) {
                 if (statement.alternate.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
-                    statement.alternate.argument && containsJsxInExpression(statement.alternate.argument)) {
+                    statement.alternate.argument &&
+                    containsJsxInExpression(statement.alternate.argument)) {
                     return true;
                 }
                 if (statement.alternate.type === utils_1.AST_NODE_TYPES.BlockStatement &&
@@ -311,10 +350,12 @@ const containsJsxInBlockStatement = (node) => {
                         return true;
                     }
                     if (statement.alternate.consequent &&
-                        ((statement.alternate.consequent.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                        ((statement.alternate.consequent.type ===
+                            utils_1.AST_NODE_TYPES.ReturnStatement &&
                             statement.alternate.consequent.argument &&
                             containsJsxInExpression(statement.alternate.consequent.argument)) ||
-                            (statement.alternate.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                            (statement.alternate.consequent.type ===
+                                utils_1.AST_NODE_TYPES.BlockStatement &&
                                 containsJsxInBlockStatement(statement.alternate.consequent)))) {
                         return true;
                     }
@@ -378,6 +419,11 @@ const containsJsxInUseMemo = (node) => {
                 if (isJsxElement(callback.body)) {
                     return true;
                 }
+                // Special case for logical expressions that can return non-JSX values
+                if (callback.body.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    callback.body.operator === '&&') {
+                    return false;
+                }
                 // For non-JSX expressions, we need to check if they contain JSX
                 return containsJsxInExpression(callback.body);
             }

package/lib/rules/require-hooks-default-params.js

@@ -25,7 +25,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
         function hasAllOptionalProperties(typeNode) {
             // Handle type literals directly
             if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
-                return typeNode.members.every(member => {
+                return typeNode.members.every((member) => {
                     if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
                         return false;
                     }
@@ -39,7 +39,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                     return false;
                 }
                 const scope = context.getScope();
-                const variable = scope.variables.find(v => v.name === typeName.name);
+                const variable = scope.variables.find((v) => v.name === typeName.name);
                 if (!variable || !variable.defs[0]?.node) {
                     // If we can't find the type definition, assume it's a type with required properties
                     // This handles cases where the type is imported from another module
@@ -50,7 +50,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                     return hasAllOptionalProperties(def.typeAnnotation);
                 }
                 else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
-                    return def.body.body.every(member => {
+                    return def.body.body.every((member) => {
                         if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
                             return false;
                         }
@@ -68,7 +68,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
             }
             // Handle interface declarations
             if (typeNode.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
-                return typeNode.body.body.every(member => {
+                return typeNode.body.body.every((member) => {
                     if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
                         return false;
                     }
@@ -106,13 +106,14 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                     return;
                 }
                 // Check if the parameter has a type annotation
-                if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {
+                if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                    param.typeAnnotation) {
                     const typeAnnotation = param.typeAnnotation.typeAnnotation;
                     if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
                         const typeName = typeAnnotation.typeName;
                         if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
                             const scope = context.getScope();
-                            const variable = scope.variables.find(v => v.name === typeName.name);
+                            const variable = scope.variables.find((v) => v.name === typeName.name);
                             if (variable && variable.defs[0]?.node) {
                                 const def = variable.defs[0].node;
                                 if (def.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
@@ -121,14 +122,16 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                             node: param,
                                             messageId: 'requireDefaultParams',
                                             fix(fixer) {
-                                                const paramText = context.getSourceCode().getText(param);
+                                                const paramText = context
+                                                    .getSourceCode()
+                                                    .getText(param);
                                                 return fixer.replaceText(param, `${paramText} = {}`);
                                             },
                                         });
                                     }
                                 }
                                 else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
-                                    if (def.body.body.every(member => {
+                                    if (def.body.body.every((member) => {
                                         if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
                                             return false;
                                         }
@@ -138,7 +141,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                             node: param,
                                             messageId: 'requireDefaultParams',
                                             fix(fixer) {
-                                                const paramText = context.getSourceCode().getText(param);
+                                                const paramText = context
+                                                    .getSourceCode()
+                                                    .getText(param);
                                                 return fixer.replaceText(param, `${paramText} = {}`);
                                             },
                                         });
@@ -148,8 +153,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                             else {
                                 // If we can't find the type definition, check if it's defined in the same file
                                 const program = context.getSourceCode().ast;
-                                const typeDefinitions = program.body.filter(node => {
-                                    if (node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                                const typeDefinitions = program.body.filter((node) => {
+                                    if (node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+                                        node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
                                         if (node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
                                             return node.id.name === typeName.name;
                                         }
@@ -167,14 +173,16 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                                 node: param,
                                                 messageId: 'requireDefaultParams',
                                                 fix(fixer) {
-                                                    const paramText = context.getSourceCode().getText(param);
+                                                    const paramText = context
+                                                        .getSourceCode()
+                                                        .getText(param);
                                                     return fixer.replaceText(param, `${paramText} = {}`);
                                                 },
                                             });
                                         }
                                     }
                                     else if (def.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
-                                        if (def.body.body.every(member => {
+                                        if (def.body.body.every((member) => {
                                             if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
                                                 return false;
                                             }
@@ -184,7 +192,9 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                                                 node: param,
                                                 messageId: 'requireDefaultParams',
                                                 fix(fixer) {
-                                                    const paramText = context.getSourceCode().getText(param);
+                                                    const paramText = context
+                                                        .getSourceCode()
+                                                        .getText(param);
                                                     return fixer.replaceText(param, `${paramText} = {}`);
                                                 },
                                             });
@@ -195,7 +205,7 @@ exports.requireHooksDefaultParams = (0, createRule_1.createRule)({
                         }
                     }
                     else if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
-                        if (typeAnnotation.members.every(member => {
+                        if (typeAnnotation.members.every((member) => {
                             if (member.type !== utils_1.AST_NODE_TYPES.TSPropertySignature) {
                                 return false;
                             }

package/lib/rules/require-usememo-object-literals.js

@@ -7,7 +7,7 @@ exports.requireUseMemoObjectLiterals = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using useMemo for inline object/array literals passed as props to JSX components to prevent unnecessary re-renders. When object/array literals are defined inline in JSX, they create new references on every render, causing child components to re-render even if the values haven\'t changed. Wrap them in useMemo to maintain referential equality.',
+            description: "Enforce using useMemo for inline object/array literals passed as props to JSX components to prevent unnecessary re-renders. When object/array literals are defined inline in JSX, they create new references on every render, causing child components to re-render even if the values haven't changed. Wrap them in useMemo to maintain referential equality.",
             recommended: 'error',
         },
         messages: {
@@ -25,7 +25,8 @@ exports.requireUseMemoObjectLiterals = (0, createRule_1.createRule)({
                 }
                 // Skip if the prop name is 'sx' or ends with 'Sx'
                 const propName = node.name.name;
-                if (typeof propName === 'string' && (propName === 'sx' || propName.endsWith('Sx'))) {
+                if (typeof propName === 'string' &&
+                    (propName === 'sx' || propName.endsWith('Sx'))) {
                     return;
                 }
                 const { expression } = node.value;

package/lib/rules/semantic-function-prefixes.js

@@ -3,8 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.semanticFunctionPrefixes = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
-const DISALLOWED_PREFIXES = new Set(['get', 'update', 'check', 'manage', 'process', 'do']);
-const NEXTJS_DATA_FUNCTIONS = new Set(['getServerSideProps', 'getStaticProps', 'getStaticPaths']);
+const DISALLOWED_PREFIXES = new Set([
+    'get',
+    'update',
+    'check',
+    'manage',
+    'process',
+    'do',
+]);
+const NEXTJS_DATA_FUNCTIONS = new Set([
+    'getServerSideProps',
+    'getStaticProps',
+    'getStaticPaths',
+]);
 const SUGGESTED_ALTERNATIVES = {
     get: ['fetch', 'retrieve', 'compute', 'derive'],
     update: ['modify', 'set', 'apply'],
@@ -75,7 +86,8 @@ exports.semanticFunctionPrefixes = (0, createRule_1.createRule)({
             if (node.id) {
                 functionName = node.id.name;
             }
-            else if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+            else if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
                 functionName = node.parent.id.name;
             }
             if (!functionName)

package/lib/rules/sync-onwrite-name-func.js

@@ -40,14 +40,16 @@ exports.syncOnwriteNameFunc = (0, createRule_1.createRule)({
                 if (!nameProperty || !funcProperty) {
                     return;
                 }
-                const nameValue = nameProperty.value.value;
+                const nameValue = nameProperty.value
+                    .value;
                 let funcName;
                 // Handle variable references
                 if (funcProperty.value.type === utils_1.AST_NODE_TYPES.Identifier) {
                     const funcIdentifier = funcProperty.value;
                     const scope = context.getScope();
-                    const variable = scope.references.find(ref => ref.identifier === funcIdentifier)?.resolved;
-                    if (variable?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    const variable = scope.references.find((ref) => ref.identifier === funcIdentifier)?.resolved;
+                    if (variable?.defs[0]?.node.type ===
+                        utils_1.AST_NODE_TYPES.VariableDeclarator &&
                         variable.defs[0].node.init?.type === utils_1.AST_NODE_TYPES.Identifier) {
                         // If the variable is initialized with another identifier, use that name
                         funcName = variable.defs[0].node.init.name;

package/lib/utils/ASTHelpers.js

@@ -262,9 +262,13 @@ class ASTHelpers {
             default:
                 break;
         }
-        // Removing duplicates
+        // Removing duplicates and ensuring exact matches only
         return [
-            ...new Set(dependencies.filter((dep) => graph?.[dep]?.type !== 'property')),
+            ...new Set(dependencies.filter((dep) => {
+                // Only include dependencies that exist exactly in the graph
+                // This prevents substring matches (e.g., 'nextMatches' vs 'nextMatchesWithResults')
+                return (graph?.[dep] !== undefined && graph?.[dep]?.type !== 'property');
+            })),
         ];
     }
     static isNode(value) {

package/lib/utils/graph/ClassGraphBuilder.js

@@ -63,7 +63,10 @@ class ClassGraphBuilder {
         return node.type === 'MethodDefinition';
     }
     addDependencies(node, methodName) {
-        const newDependencies = ASTHelpers_1.ASTHelpers.classMethodDependenciesOf(node, this.graph, this.className).filter((name) => !!this.graph[name] && name !== methodName);
+        const newDependencies = ASTHelpers_1.ASTHelpers.classMethodDependenciesOf(node, this.graph, this.className).filter((name) => {
+            // Only include dependencies that exist exactly in the graph and aren't self-references
+            return !!this.graph[name] && name !== methodName;
+        });
         if (this.graph[methodName]) {
             // Ensure dependencies is initialized as an array
             if (!Array.isArray(this.graph[methodName].dependencies)) {

package/lib/utils/graph/ClassGraphSorterReadability.js

@@ -72,7 +72,9 @@ class ClassGraphSorterReadability extends ClassGraphSorter_1.ClassGraphSorter {
             visited.add(node.name);
             dfsSortedNodes.push(node);
             // Ensure node.dependencies exists and is an array before iterating
-            const dependencies = Array.isArray(node.dependencies) ? node.dependencies : [];
+            const dependencies = Array.isArray(node.dependencies)
+                ? node.dependencies
+                : [];
             for (const dep of dependencies) {
                 const depNode = this.graph[String(dep)];
                 if (depNode) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",
@@ -30,11 +30,11 @@
     "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
     "lint:js": "eslint ./src",
     "lint:shell": "shellcheck .devcontainer/git-flow-completion.bash",
-    "lint:fix": "tsc && eslint ./**/* --quiet --fix",
+    "lint:fix": "tsc && eslint \"./src/**/*\" --quiet --fix",
     "test": "jest --passWithNoTests --reporters=default --reporters=jest-junit",
     "test:ci": "jest --ci --passWithNoTests --reporters=default --reporters=jest-junit",
     "docs": "./scripts/make-docs.sh && npm run update:eslint-docs",
-    "update:eslint-docs": "eslint-doc-generator",
+    "update:eslint-docs": "eslint-doc-generator --init-rule-docs",
     "build": "tsc",
     "prepare": "husky install && npm run build",
     "version": "git add -A src",

package/lib/rules/require-image-overlayed.d.ts

@@ -1,7 +0,0 @@
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"useImageOverlayed", {
-    componentPath: string;
-}[], {
-    JSXElement(node: any): void;
-    ImportDeclaration(node: any): void;
-}>;
-export = _default;

package/lib/rules/require-image-overlayed.js

@@ -1,82 +0,0 @@
-"use strict";
-const createRule_1 = require("../utils/createRule");
-module.exports = (0, createRule_1.createRule)({
-    name: 'require-image-overlayed',
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Enforce using ImageOverlayed component instead of next/image or img tags',
-            recommended: 'error',
-            requiresTypeChecking: false,
-        },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    componentPath: {
-                        type: 'string',
-                        description: 'The import path for the ImageOverlayed component',
-                        default: 'src/components/ImageOverlayed',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            useImageOverlayed: 'Use ImageOverlayed component from {{ componentPath }} instead of {{ component }}',
-        },
-    },
-    defaultOptions: [{ componentPath: 'src/components/ImageOverlayed' }],
-    create(context) {
-        const options = context.options[0] || {
-            componentPath: 'src/components/ImageOverlayed',
-        };
-        const sourceCode = context.getSourceCode();
-        return {
-            // Handle JSX img elements
-            JSXElement(node) {
-                if (node.openingElement.name.name === 'img') {
-                    context.report({
-                        node,
-                        messageId: 'useImageOverlayed',
-                        data: {
-                            componentPath: options.componentPath,
-                            component: 'img tag',
-                        },
-                        fix(fixer) {
-                            const attributes = node.openingElement.attributes
-                                .map((attr) => sourceCode.getText(attr))
-                                .join(' ');
-                            return fixer.replaceText(node, `<ImageOverlayed ${attributes} />`);
-                        },
-                    });
-                }
-            },
-            // Handle next/image imports and usage
-            ImportDeclaration(node) {
-                if (node.source.value === 'next/image' && node.specifiers.length > 0) {
-                    const imageSpecifier = node.specifiers.find((spec) => (spec.type === 'ImportDefaultSpecifier' ||
-                        spec.type === 'ImportSpecifier') &&
-                        (spec.local.name === 'Image' || spec.imported?.name === 'Image'));
-                    if (imageSpecifier) {
-                        const localName = imageSpecifier.local.name;
-                        // Report the import
-                        context.report({
-                            node,
-                            messageId: 'useImageOverlayed',
-                            data: {
-                                componentPath: options.componentPath,
-                                component: 'next/image',
-                            },
-                            fix(fixer) {
-                                return fixer.replaceText(node, `import ${localName} from '${options.componentPath}';`);
-                            },
-                        });
-                    }
-                }
-            },
-        };
-    },
-});
-//# sourceMappingURL=require-image-overlayed.js.map