@blumintinc/eslint-plugin-blumint 1.4.0 → 1.5.1

package/lib/rules/enforce-verb-noun-naming.js

@@ -7,7 +7,10 @@ exports.enforceVerbNounNaming = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const compromise_1 = __importDefault(require("compromise"));
-const PREPOSITIONS = ['to', 'from', 'with', 'by', 'at', 'of'];
+const verbs_json_1 = __importDefault(require("../utils/verbs.json"));
+const PREPOSITIONS = new Set(['to', 'from', 'with', 'by', 'at', 'of']);
+// Create a Set from the verbs list for O(1) lookup
+const VERBS_SET = new Set(verbs_json_1.default);
 exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
     name: 'enforce-verb-noun-naming',
     meta: {
@@ -31,28 +34,41 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             const words = rest.split(/(?=[A-Z])/);
             return firstChar + words[0];
         }
-        function toSentence(name) {
+        function toPhrase(name) {
             return name.split(/(?=[A-Z])/).join(' ');
         }
-        function getPossibleTags(sentence) {
+        function getPossibleTags(sentence, index = 0) {
             const doc = (0, compromise_1.default)(sentence);
             const terms = doc.terms().json();
-            if (terms.length === 0 || !terms[0].terms || !terms[0].terms[0].tags)
+            if (terms.length < index ||
+                !terms[index]?.terms?.length ||
+                !terms[index]?.terms[0]?.tags)
                 return [];
-            const tags = terms[0].terms[0].tags;
+            const tags = terms[index].terms[0].tags;
             return tags;
         }
         function isVerbPhrase(name) {
             const firstWord = extractFirstWord(name);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (PREPOSITIONS.includes(firstWord.toLowerCase())) {
+            const firstWordLower = firstWord.toLowerCase();
+            // Check for prepositions first
+            if (PREPOSITIONS.has(firstWordLower)) {
                 return true;
             }
-            const tags = getPossibleTags(toSentence(name));
-            const isVerb = tags.includes('Verb');
-            const isPreposition = tags.includes('Preposition');
-            const isConjunction = tags.includes('Conjunction');
-            return isVerb || isPreposition || isConjunction;
+            // Check against our comprehensive verbs list first
+            if (VERBS_SET.has(firstWordLower)) {
+                return true;
+            }
+            // Fall back to NLP approach if not found in verbs list
+            const withoutPrefixTags = getPossibleTags(toPhrase(name));
+            // Check if either form is recognized as a verb
+            const isVerb = withoutPrefixTags.includes('Verb');
+            const isPreposition = withoutPrefixTags.includes('Preposition');
+            const isConjunction = withoutPrefixTags.includes('Conjunction');
+            // For non-prepositions/conjunctions, require verb form
+            if (isPreposition || isConjunction) {
+                return true;
+            }
+            return isVerb;
         }
         function isJsxReturnFunction(node) {
             if (node.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration &&
@@ -99,6 +115,12 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
             MethodDefinition(node) {
                 if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                     return;
+                // Skip getters since they represent properties and should use noun phrases
+                if (node.kind === 'get')
+                    return;
+                // Skip constructors since they are special class methods
+                if (node.kind === 'constructor')
+                    return;
                 if (!isVerbPhrase(node.key.name)) {
                     context.report({
                         node: node.key,

package/lib/rules/no-async-array-filter.js

@@ -27,12 +27,12 @@ exports.noAsyncArrayFilter = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Disallow async callbacks for Array.filter',
+            description: 'Disallow async callbacks in Array.filter() as they lead to incorrect filtering. Since async functions return Promises which are always truthy, the filter will keep all elements regardless of the async check\'s result. Use Promise.all() with map() first, then filter based on the resolved results.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            unexpected: 'Async array filter is dangerous as a Promise object will always be truthy. You should move the asynchronous logic elsewhere.',
+            unexpected: 'Async array filter is dangerous as a Promise object will always be truthy. Instead of `array.filter(async x => await someCheck(x))`, first resolve the promises with `Promise.all()` or move the async logic elsewhere: `const results = await Promise.all(array.map(x => someCheck(x))); array.filter((_, i) => results[i])`.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-async-foreach.js

@@ -24,7 +24,7 @@ exports.noAsyncForEach = {
     meta: {
         type: 'problem',
         docs: {
-            description: 'Disallow Array.forEach with an async callback function',
+            description: 'Disallow Array.forEach with an async callback function as it does not wait for promises to resolve. This can lead to race conditions and unexpected behavior. Use a standard for...of loop for sequential execution or Promise.all with map for concurrent execution.',
             recommended: 'error',
         },
         messages: {

package/lib/rules/no-class-instance-destructuring.d.ts

@@ -0,0 +1 @@
+export declare const noClassInstanceDestructuring: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noClassInstanceDestructuring", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-class-instance-destructuring.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noClassInstanceDestructuring = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noClassInstanceDestructuring = (0, createRule_1.createRule)({
+    name: 'no-class-instance-destructuring',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow destructuring of class instances to prevent loss of `this` context',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            noClassInstanceDestructuring: 'Avoid destructuring class instances as it can lead to loss of `this` context. Use direct property access instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function isClassInstance(node) {
+            // Check for new expressions
+            if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                return true;
+            }
+            // Check for identifiers that might be class instances
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const variableDef = context
+                    .getScope()
+                    .variables.find((variableDef) => variableDef.name === node.name);
+                if (variableDef?.defs[0]?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                    const init = variableDef.defs[0].node
+                        .init;
+                    return init?.type === utils_1.AST_NODE_TYPES.NewExpression;
+                }
+            }
+            return false;
+        }
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                    node.init &&
+                    isClassInstance(node.init)) {
+                    const objectPattern = node.id;
+                    context.report({
+                        node,
+                        messageId: 'noClassInstanceDestructuring',
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+                            const properties = objectPattern.properties;
+                            // Skip if there's no init expression
+                            if (!node.init)
+                                return null;
+                            // For single property, use simple replacement
+                            if (properties.length === 1) {
+                                const prop = properties[0];
+                                if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                                    const key = prop.key.type === utils_1.AST_NODE_TYPES.Identifier
+                                        ? prop.key.name
+                                        : sourceCode.getText(prop.key);
+                                    const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
+                                        ? prop.value.name
+                                        : sourceCode.getText(prop.value);
+                                    const initText = sourceCode.getText(node.init);
+                                    return fixer.replaceText(node, `${value} = ${initText}.${key}`);
+                                }
+                                return null;
+                            }
+                            // For multiple properties, create multiple declarations
+                            const declarations = properties
+                                .filter((prop) => prop.type === utils_1.AST_NODE_TYPES.Property)
+                                .map((prop) => {
+                                const key = prop.key.type === utils_1.AST_NODE_TYPES.Identifier
+                                    ? prop.key.name
+                                    : sourceCode.getText(prop.key);
+                                const value = prop.value.type === utils_1.AST_NODE_TYPES.Identifier
+                                    ? prop.value.name
+                                    : sourceCode.getText(prop.value);
+                                const initText = sourceCode.getText(node.init);
+                                return `${value} = ${initText}.${key}`;
+                            })
+                                .join(';\nconst ');
+                            // Only apply the fix if we have valid declarations
+                            if (!declarations)
+                                return null;
+                            return fixer.replaceText(node, declarations);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-class-instance-destructuring.js.map

package/lib/rules/no-compositing-layer-props.js

@@ -37,7 +37,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Warn when using CSS properties that trigger compositing layers',
+            description: 'Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. Consider alternatives or explicitly document intentional layer promotion.',
             recommended: 'error',
         },
         schema: [],

package/lib/rules/no-conditional-literals-in-jsx.js

@@ -14,7 +14,7 @@ exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unexpected: 'Conditional expression is a sibling of raw text and must be wrapped in <div> or <span>',
+            unexpected: 'Conditional text literals must be wrapped in a container element when next to other text. Instead of `<div>text {condition && "more text"}</div>`, use `<div>text <span>{condition && "more text"}</span></div>` to prevent React hydration issues.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-entire-object-hook-deps.js

@@ -136,7 +136,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used. Requires TypeScript and `parserOptions.project` to be configured.',
+            description: 'Avoid using entire objects in React hook dependency arrays when only specific fields are used, as this can cause unnecessary re-renders. When a hook only uses obj.name but obj is in the deps array, any change to obj.age will trigger the hook. Use individual fields (obj.name) instead of the entire object. Requires TypeScript and `parserOptions.project` to be configured.',
             recommended: 'error',
             requiresTypeChecking: true,
         },

package/lib/rules/no-explicit-return-type.d.ts

@@ -6,6 +6,7 @@ type Options = [
         allowInterfaceMethodSignatures?: boolean;
         allowAbstractMethodSignatures?: boolean;
         allowDtsFiles?: boolean;
+        allowFirestoreFunctionFiles?: boolean;
     }
 ];
 export declare const noExplicitReturnType: TSESLint.RuleModule<'noExplicitReturnType', Options>;

package/lib/rules/no-explicit-return-type.js

@@ -9,6 +9,7 @@ const defaultOptions = {
     allowInterfaceMethodSignatures: true,
     allowAbstractMethodSignatures: true,
     allowDtsFiles: true,
+    allowFirestoreFunctionFiles: true,
 };
 function isRecursiveFunction(node) {
     const functionName = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration
@@ -91,7 +92,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Disallow explicit return types on functions',
+            description: 'Disallow explicit return type annotations on functions when TypeScript can infer them. This reduces code verbosity and maintenance burden while leveraging TypeScript\'s powerful type inference. Exceptions are made for recursive functions, overloaded functions, interface methods, and abstract methods where explicit types improve clarity.',
             recommended: 'error',
             requiresTypeChecking: false,
             extendsBaseRule: false,
@@ -106,6 +107,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     allowInterfaceMethodSignatures: { type: 'boolean' },
                     allowAbstractMethodSignatures: { type: 'boolean' },
                     allowDtsFiles: { type: 'boolean' },
+                    allowFirestoreFunctionFiles: { type: 'boolean' },
                 },
                 additionalProperties: false,
             },
@@ -118,7 +120,8 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
     create(context, [options]) {
         const mergedOptions = { ...defaultOptions, ...options };
         const filename = context.getFilename();
-        if (mergedOptions.allowDtsFiles && filename.endsWith('.d.ts')) {
+        if ((mergedOptions.allowDtsFiles && filename.endsWith('.d.ts')) ||
+            (mergedOptions.allowFirestoreFunctionFiles && filename.endsWith('.f.ts'))) {
             return {};
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/lib/rules/no-filter-without-return.js

@@ -33,7 +33,7 @@ exports.noFilterWithoutReturn = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            unexpected: 'An array filter callback with a block statement must contain a return statement',
+            unexpected: 'Array.filter callbacks with block statements must contain a return statement. Instead of `array.filter(x => { doSomething(x); })`, use `array.filter(x => { doSomething(x); return someCondition; })` or use implicit return `array.filter(x => someCondition)`.',
         },
     },
     defaultOptions: [],

package/lib/rules/no-firestore-object-arrays.d.ts

@@ -0,0 +1 @@
+export declare const noFirestoreObjectArrays: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noObjectArrays", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-firestore-object-arrays.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFirestoreObjectArrays = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const PRIMITIVE_TYPES = new Set([
+    'string',
+    'number',
+    'boolean',
+    'Date',
+    'Timestamp',
+    'null',
+    'undefined',
+    'GeoPoint',
+]);
+const isInFirestoreTypesDirectory = (filename) => {
+    return filename.includes('functions/src/types/firestore');
+};
+const isObjectType = (node) => {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSTypeReference:
+            if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const typeName = node.typeName.name;
+                return !PRIMITIVE_TYPES.has(typeName);
+            }
+            else if (node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                // Handle namespace.Type cases
+                return true;
+            }
+            return true;
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+            return node.types.some(isObjectType);
+        case utils_1.AST_NODE_TYPES.TSMappedType:
+        case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
+            return true;
+        default:
+            return false;
+    }
+};
+exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
+    name: 'no-firestore-object-arrays',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow arrays of objects in Firestore type definitions to optimize performance and avoid unnecessary fetches',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            noObjectArrays: 'Arrays of objects are not recommended in Firestore. Use subcollections, arrays of IDs, or structured maps (Record<string, T>) instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        if (!isInFirestoreTypesDirectory(context.getFilename())) {
+            return {};
+        }
+        return {
+            TSArrayType(node) {
+                if (isObjectType(node.elementType)) {
+                    context.report({
+                        node,
+                        messageId: 'noObjectArrays',
+                    });
+                }
+            },
+            TSTypeReference(node) {
+                // Handle Array<T> and ReadonlyArray<T> syntax
+                const typeName = node.typeName.name;
+                if ((typeName === 'Array' || typeName === 'ReadonlyArray') && node.typeParameters) {
+                    const elementType = node.typeParameters.params[0];
+                    if (isObjectType(elementType)) {
+                        context.report({
+                            node,
+                            messageId: 'noObjectArrays',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-firestore-object-arrays.js.map

package/lib/rules/no-jsx-in-hooks.d.ts

@@ -0,0 +1 @@
+export declare const noJsxInHooks: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noJsxInHooks", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-jsx-in-hooks.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noJsxInHooks = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const isJsxElement = (node) => {
+    if (!node)
+        return false;
+    if (node.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+        return isJsxElement(node.consequent) || isJsxElement(node.alternate);
+    }
+    return (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
+        node.type === utils_1.AST_NODE_TYPES.JSXFragment ||
+        node.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer);
+};
+const isJsxReturnType = (node) => {
+    if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        const typeName = node.typeAnnotation.typeName;
+        if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return ['JSX', 'ReactNode', 'ReactElement'].includes(typeName.name);
+        }
+        if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+            return typeName.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeName.left.name === 'JSX' &&
+                typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
+                typeName.right.name === 'Element';
+        }
+    }
+    return false;
+};
+const containsJsxInBlockStatement = (node) => {
+    const variablesWithJsx = new Set();
+    for (const statement of node.body) {
+        // Check variable declarations for JSX assignments
+        if (statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            for (const declarator of statement.declarations) {
+                if (declarator.init) {
+                    if (declarator.init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        containsJsxInUseMemo(declarator.init)) {
+                        if (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            variablesWithJsx.add(declarator.id.name);
+                        }
+                    }
+                }
+            }
+        }
+        // Check return statements
+        if (statement.type === utils_1.AST_NODE_TYPES.ReturnStatement && statement.argument) {
+            if (isJsxElement(statement.argument)) {
+                return true;
+            }
+            if (statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                if (containsJsxInUseMemo(statement.argument)) {
+                    return true;
+                }
+            }
+            if (statement.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                variablesWithJsx.has(statement.argument.name)) {
+                return true;
+            }
+        }
+        // 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) {
+                if (isJsxElement(statement.consequent.argument)) {
+                    return true;
+                }
+                if (statement.consequent.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    variablesWithJsx.has(statement.consequent.argument.name)) {
+                    return true;
+                }
+            }
+            if (statement.consequent.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                containsJsxInBlockStatement(statement.consequent)) {
+                return true;
+            }
+            if (statement.alternate) {
+                if (statement.alternate.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
+                    statement.alternate.argument) {
+                    if (isJsxElement(statement.alternate.argument)) {
+                        return true;
+                    }
+                    if (statement.alternate.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        variablesWithJsx.has(statement.alternate.argument.name)) {
+                        return true;
+                    }
+                }
+                if (statement.alternate.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+                    containsJsxInBlockStatement(statement.alternate)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+const containsJsxInUseMemo = (node) => {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.callee.name === 'useMemo' &&
+        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) {
+            const body = callback.body;
+            if (isJsxElement(body)) {
+                return true;
+            }
+            if (body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                return containsJsxInBlockStatement(body);
+            }
+            if (body.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                body.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                body.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                body.callee.property.name === 'map') {
+                const mapCallback = body.arguments[0];
+                if ((mapCallback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    mapCallback.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
+                    isJsxElement(mapCallback.body)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+exports.noJsxInHooks = (0, createRule_1.createRule)({
+    name: 'no-jsx-in-hooks',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent hooks from returning JSX',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noJsxInHooks: 'Hooks should not return JSX. Convert this hook into a component or extract the JSX into a separate component.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            FunctionDeclaration(node) {
+                if (node.id && node.id.name.startsWith('use')) {
+                    // Check return type annotation
+                    if (node.returnType && isJsxReturnType(node.returnType)) {
+                        context.report({
+                            node: node.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check return statements
+                    if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        if (containsJsxInBlockStatement(node.body)) {
+                            context.report({
+                                node: node.id,
+                                messageId: 'noJsxInHooks',
+                            });
+                        }
+                    }
+                }
+            },
+            ArrowFunctionExpression(node) {
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    parent.id.name.startsWith('use')) {
+                    // Check return type annotation
+                    if (node.returnType && isJsxReturnType(node.returnType)) {
+                        context.report({
+                            node: parent.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check direct JSX return
+                    if (isJsxElement(node.body)) {
+                        context.report({
+                            node: parent.id,
+                            messageId: 'noJsxInHooks',
+                        });
+                        return;
+                    }
+                    // Check block body returns
+                    if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                        if (containsJsxInBlockStatement(node.body)) {
+                            context.report({
+                                node: parent.id,
+                                messageId: 'noJsxInHooks',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-jsx-in-hooks.js.map

package/lib/rules/no-memoize-on-static.d.ts

@@ -0,0 +1 @@
+export declare const noMemoizeOnStatic: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noMemoizeOnStatic", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-memoize-on-static.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMemoizeOnStatic = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noMemoizeOnStatic = (0, createRule_1.createRule)({
+    name: 'no-memoize-on-static',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent using @Memoize() decorator on static methods',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMemoizeOnStatic: '@Memoize() decorator should not be used on static methods',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track renamed imports of Memoize
+        const memoizeAliases = new Set(['Memoize']);
+        return {
+            ImportSpecifier(node) {
+                if (node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.imported.name === 'Memoize' &&
+                    node.local.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    memoizeAliases.add(node.local.name);
+                }
+            },
+            'MethodDefinition[static=true]'(node) {
+                if (node.decorators) {
+                    for (const decorator of node.decorators) {
+                        const expr = decorator.expression;
+                        if (
+                        // Handle @Memoize()
+                        (expr.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                            expr.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            memoizeAliases.has(expr.callee.name)) ||
+                            // Handle @Memoize (without parentheses)
+                            (expr.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                memoizeAliases.has(expr.name))) {
+                            context.report({
+                                node: decorator,
+                                messageId: 'noMemoizeOnStatic',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-memoize-on-static.js.map

package/lib/rules/no-misused-switch-case.js

@@ -7,12 +7,12 @@ exports.noMisusedSwitchCase = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Prevent misuse of logical OR in switch case statements',
+            description: 'Prevent misuse of logical OR (||) in switch case statements, which can lead to confusing and error-prone code. Instead of using OR operators in case expressions, use multiple case statements in sequence to handle multiple values. This improves code readability and follows the standard switch-case pattern.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            noMisusedSwitchCase: 'Avoid using logical OR  in switch case. Use cascading cases instead.',
+            noMisusedSwitchCase: 'Avoid using logical OR (||) in switch case statements. Instead of `case x || y:`, use cascading cases like `case x: case y:`.',
         },
     },
     defaultOptions: [],