@blumintinc/eslint-plugin-blumint 1.1.9 → 1.2.0

package/README.md

@@ -59,12 +59,14 @@ Or use the recommended config:
 | Name                                                                                     | Description                                                                                                                                     | 💼 | ⚠️ | 🔧 |
 | :--------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------- | :- | :- | :- |
 | [array-methods-this-context](docs/rules/array-methods-this-context.md)                   | Prevent misuse of Array methods in OOP                                                                                                          |    | ✅  |    |
+| [avoid-utils-directory](docs/rules/avoid-utils-directory.md)                             | Enforce using util/ instead of utils/ directory                                                                                                 | ✅  |    | 🔧 |
 | [class-methods-read-top-to-bottom](docs/rules/class-methods-read-top-to-bottom.md)       | Ensures classes read linearly from top to bottom.                                                                                               |    | ✅  | 🔧 |
 | [consistent-callback-naming](docs/rules/consistent-callback-naming.md)                   | Enforce consistent naming conventions for callback props and functions                                                                          | ✅  |    | 🔧 |
 | [dynamic-https-errors](docs/rules/dynamic-https-errors.md)                               | Dynamic error details should only be in the third argument of the HttpsError constructor. The second argument is hashed to produce a unique id. |    | ✅  |    |
 | [enforce-callable-types](docs/rules/enforce-callable-types.md)                           | Enforce Params and Response type exports in callable functions                                                                                  | ✅  |    |    |
 | [enforce-callback-memo](docs/rules/enforce-callback-memo.md)                             | Enforce useCallback or useMemo for inline functions in JSX props                                                                                | ✅  |    |    |
 | [enforce-dynamic-firebase-imports](docs/rules/enforce-dynamic-firebase-imports.md)       | Enforce dynamic importing for modules within the firebaseCloud directory                                                                        | ✅  |    |    |
+| [enforce-firestore-path-utils](docs/rules/enforce-firestore-path-utils.md)               | Enforce usage of utility functions for Firestore paths                                                                                          | ✅  |    |    |
 | [enforce-identifiable-firestore-type](docs/rules/enforce-identifiable-firestore-type.md) | Enforce that Firestore type definitions extend Identifiable and match their folder name                                                         | ✅  |    |    |
 | [enforce-safe-stringify](docs/rules/enforce-safe-stringify.md)                           | Enforce using safe-stable-stringify instead of JSON.stringify                                                                                   | ✅  |    | 🔧 |
 | [export-if-in-doubt](docs/rules/export-if-in-doubt.md)                                   | All top-level const definitions, type definitions, and functions should be exported                                                             |    |    |    |
@@ -74,6 +76,7 @@ Or use the recommended config:
 | [no-async-array-filter](docs/rules/no-async-array-filter.md)                             | Disallow async callbacks for Array.filter                                                                                                       | ✅  |    |    |
 | [no-async-foreach](docs/rules/no-async-foreach.md)                                       | Disallow Array.forEach with an async callback function                                                                                          | ✅  |    |    |
 | [no-conditional-literals-in-jsx](docs/rules/no-conditional-literals-in-jsx.md)           | Disallow use of conditional literals in JSX code                                                                                                | ✅  |    |    |
+| [no-entire-object-hook-deps](docs/rules/no-entire-object-hook-deps.md)                   | Avoid using entire objects in React hook dependency arrays when only specific fields are used                                                   | ✅  |    | 🔧 |
 | [no-filter-without-return](docs/rules/no-filter-without-return.md)                       | Disallow Array.filter callbacks without an explicit return (if part of a block statement)                                                       | ✅  |    |    |
 | [no-jsx-whitespace-literal](docs/rules/no-jsx-whitespace-literal.md)                     | Disallow the use of {" "} elements in JSX code                                                                                                  | ✅  |    |    |
 | [no-misused-switch-case](docs/rules/no-misused-switch-case.md)                           | Prevent misuse of logical OR in switch case statements                                                                                          | ✅  |    |    |

package/lib/index.js

@@ -36,10 +36,11 @@ const enforce_safe_stringify_1 = require("./rules/enforce-safe-stringify");
 const avoid_utils_directory_1 = require("./rules/avoid-utils-directory");
 const no_entire_object_hook_deps_1 = require("./rules/no-entire-object-hook-deps");
 const enforce_firestore_path_utils_1 = require("./rules/enforce-firestore-path-utils");
+const no_compositing_layer_props_1 = require("./rules/no-compositing-layer-props");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.1.9',
+        version: '1.2.0',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -81,6 +82,7 @@ module.exports = {
                 '@blumintinc/blumint/require-usememo-object-literals': 'error',
                 '@blumintinc/blumint/enforce-safe-stringify': 'error',
                 '@blumintinc/blumint/no-entire-object-hook-deps': 'error',
+                '@blumintinc/blumint/no-compositing-layer-props': 'warn',
             },
         },
     },
@@ -118,6 +120,7 @@ module.exports = {
         'avoid-utils-directory': avoid_utils_directory_1.avoidUtilsDirectory,
         'no-entire-object-hook-deps': no_entire_object_hook_deps_1.noEntireObjectHookDeps,
         'enforce-firestore-path-utils': enforce_firestore_path_utils_1.enforceFirestorePathUtils,
+        'no-compositing-layer-props': no_compositing_layer_props_1.noCompositingLayerProps,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/enforce-exported-function-types.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'missingExportedType' | 'missingExportedReturnType' | 'missingExportedPropsType';
+export declare const enforceExportedFunctionTypes: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-exported-function-types.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceExportedFunctionTypes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
+    name: 'enforce-exported-function-types',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce exporting types for function props and return values',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            missingExportedType: 'Type {{typeName}} should be exported since it is used in an exported function',
+            missingExportedReturnType: 'Return type {{typeName}} should be exported since it is used in an exported function',
+            missingExportedPropsType: 'Props type {{typeName}} should be exported since it is used in an exported React component',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const reportedTypes = new Set();
+        function isExported(node) {
+            if (!node)
+                return false;
+            if (node.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+                node.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
+                return true;
+            }
+            const parent = node.parent;
+            if (!parent)
+                return false;
+            if (parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+                parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration ||
+                parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator && isExported(parent.parent)) {
+                return true;
+            }
+            return false;
+        }
+        function getTypeName(node) {
+            if (!node)
+                return undefined;
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.TSTypeReference:
+                    if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        return node.typeName.name;
+                    }
+                    break;
+                case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+                    return 'AnonymousType';
+            }
+            return undefined;
+        }
+        function isTypeExported(typeName) {
+            const sourceCode = context.getSourceCode();
+            const program = sourceCode.ast;
+            // Check for exported type declarations
+            const exportedTypes = program.body.filter(node => {
+                if (node.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                    if (node.declaration?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                        return node.declaration.id.name === typeName;
+                    }
+                    if (node.declaration?.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                        return node.declaration.id.name === typeName;
+                    }
+                }
+                return false;
+            });
+            if (exportedTypes.length > 0) {
+                return true;
+            }
+            // Check for type aliases in the current scope
+            const scope = context.getScope();
+            const variable = scope.variables.find(v => v.name === typeName);
+            if (!variable)
+                return false;
+            const def = variable.defs[0];
+            if (!def)
+                return false;
+            // Check if the type is directly exported
+            if (isExported(def.node))
+                return true;
+            // Check if the type is part of an export declaration
+            const parent = def.node.parent;
+            if (!parent)
+                return false;
+            // Handle type aliases in export declarations
+            if (parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                return true;
+            }
+            // Handle type aliases in variable declarations
+            if (parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+                if (parent.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                    return true;
+                }
+            }
+            // Handle type aliases in interface declarations
+            if (parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                if (parent.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return {
+            FunctionDeclaration(node) {
+                if (!isExported(node))
+                    return;
+                // Skip React components
+                if (node.id?.name && /^[A-Z]/.test(node.id.name))
+                    return;
+                // Check return type
+                if (node.returnType?.typeAnnotation) {
+                    const typeName = getTypeName(node.returnType.typeAnnotation);
+                    if (typeName && !isTypeExported(typeName)) {
+                        // Check if we've already reported this type
+                        const key = `${typeName}-${node.loc?.start.line}-${node.loc?.start.column}`;
+                        if (!reportedTypes.has(key)) {
+                            reportedTypes.add(key);
+                            context.report({
+                                node: node.returnType,
+                                messageId: 'missingExportedReturnType',
+                                data: { typeName },
+                            });
+                        }
+                    }
+                }
+                // Check parameter types
+                node.params.forEach(param => {
+                    if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+                        const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                        if (typeName && !isTypeExported(typeName)) {
+                            // Check if we've already reported this type
+                            const key = `${typeName}-${param.loc?.start.line}-${param.loc?.start.column}`;
+                            if (!reportedTypes.has(key)) {
+                                reportedTypes.add(key);
+                                context.report({
+                                    node: param.typeAnnotation,
+                                    messageId: 'missingExportedType',
+                                    data: { typeName },
+                                });
+                            }
+                        }
+                    }
+                });
+            },
+            'VariableDeclarator > ArrowFunctionExpression'(node) {
+                if (!node.parent?.parent || !isExported(node.parent.parent))
+                    return;
+                // Skip React components
+                if (node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    /^[A-Z]/.test(node.parent.id.name))
+                    return;
+                // Check return type
+                if (node.returnType?.typeAnnotation) {
+                    const typeName = getTypeName(node.returnType.typeAnnotation);
+                    if (typeName && !isTypeExported(typeName)) {
+                        // Check if we've already reported this type
+                        const key = `${typeName}-${node.loc?.start.line}-${node.loc?.start.column}`;
+                        if (!reportedTypes.has(key)) {
+                            reportedTypes.add(key);
+                            context.report({
+                                node: node.returnType,
+                                messageId: 'missingExportedReturnType',
+                                data: { typeName },
+                            });
+                        }
+                    }
+                }
+                // Check parameter types
+                node.params.forEach(param => {
+                    if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+                        const typeName = getTypeName(param.typeAnnotation.typeAnnotation);
+                        if (typeName && !isTypeExported(typeName)) {
+                            // Check if we've already reported this type
+                            const key = `${typeName}-${param.loc?.start.line}-${param.loc?.start.column}`;
+                            if (!reportedTypes.has(key)) {
+                                reportedTypes.add(key);
+                                context.report({
+                                    node: param.typeAnnotation,
+                                    messageId: 'missingExportedType',
+                                    data: { typeName },
+                                });
+                            }
+                        }
+                    }
+                });
+            },
+            // Handle React components
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation]'(node) {
+                if (!isExported(node.parent))
+                    return;
+                // Check props parameter
+                if (node.typeAnnotation) {
+                    const typeName = getTypeName(node.typeAnnotation.typeAnnotation);
+                    if (typeName && !isTypeExported(typeName)) {
+                        // Check if we've already reported this type
+                        const key = `${typeName}-${node.loc?.start.line}-${node.loc?.start.column}`;
+                        if (!reportedTypes.has(key)) {
+                            reportedTypes.add(key);
+                            context.report({
+                                node: node.typeAnnotation,
+                                messageId: 'missingExportedType',
+                                data: { typeName },
+                            });
+                            return;
+                        }
+                    }
+                }
+            },
+            // Skip type checking for React components since we handle them separately
+            'FunctionDeclaration[id.name=/^[A-Z]/] > TSTypeAnnotation'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > TSTypeAnnotation > TSTypeReference'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > TSTypeAnnotation'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > TSTypeAnnotation > TSTypeReference'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
+            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
+        };
+    },
+});
+//# sourceMappingURL=enforce-exported-function-types.js.map

package/lib/rules/enforce-memoize-async.d.ts

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

package/lib/rules/enforce-memoize-async.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceMemoizeAsync = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
+    name: 'enforce-memoize-async',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce @Memoize() decorator on async methods with 0-1 parameters',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            requireMemoize: 'Async methods with 0-1 parameters should be decorated with @Memoize()',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        let hasMemoizeImport = false;
+        let memoizeAlias = 'Memoize';
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'typescript-memoize') {
+                    const memoizeSpecifier = node.specifiers.find(spec => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        spec.imported.name === 'Memoize');
+                    if (memoizeSpecifier) {
+                        hasMemoizeImport = true;
+                        if (memoizeSpecifier.local) {
+                            memoizeAlias = memoizeSpecifier.local.name;
+                        }
+                    }
+                }
+            },
+            MethodDefinition(node) {
+                // Only process async methods
+                if (node.value.type !== utils_1.AST_NODE_TYPES.FunctionExpression || !node.value.async) {
+                    return;
+                }
+                // Skip methods with more than one parameter
+                if (node.value.params.length > 1) {
+                    return;
+                }
+                // Check if method already has @Memoize decorator
+                const hasDecorator = node.decorators?.some(decorator => {
+                    if (decorator.expression.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                        return false;
+                    }
+                    const callee = decorator.expression.callee;
+                    return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        callee.name === memoizeAlias);
+                });
+                if (!hasDecorator && hasMemoizeImport) {
+                    context.report({
+                        node,
+                        messageId: 'requireMemoize',
+                        fix(fixer) {
+                            // Add import if needed
+                            // Add decorator
+                            return fixer.insertTextBefore(node, `@${memoizeAlias}()\n${' '.repeat(node.loc.start.column)}`);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-memoize-async.js.map

package/lib/rules/no-compositing-layer-props.d.ts

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

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noCompositingLayerProps = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// Convert camelCase to kebab-case
+function toKebabCase(str) {
+    return str.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
+}
+// Normalize property name to kebab-case for consistent lookup
+function normalizePropertyName(name) {
+    // If already contains hyphens, assume it's kebab-case
+    if (name.includes('-'))
+        return name.toLowerCase();
+    // Convert camelCase to kebab-case
+    return toKebabCase(name).toLowerCase();
+}
+const COMPOSITING_PROPERTIES = new Set([
+    'filter',
+    'backdrop-filter',
+    'will-change',
+    'transform',
+    'perspective',
+    'backface-visibility',
+    'contain',
+    'mix-blend-mode',
+    'opacity',
+]);
+const COMPOSITING_VALUES = new Set([
+    'translate3d',
+    'scale3d',
+    'translateZ',
+    'transparent',
+]);
+exports.noCompositingLayerProps = (0, createRule_1.createRule)({
+    name: 'no-compositing-layer-props',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Warn when using CSS properties that trigger compositing layers',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            compositingLayer: '{{property}} may trigger a new compositing layer which can impact performance. Consider using alternative properties or add an eslint-disable comment if the layer promotion is intentional.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const seenNodes = new WeakSet();
+        function checkPropertyValue(value) {
+            return COMPOSITING_VALUES.has(value) ||
+                value.includes('translate3d') ||
+                value.includes('scale3d') ||
+                value.includes('translateZ');
+        }
+        function checkProperty(propertyName, propertyValue) {
+            const normalizedName = normalizePropertyName(propertyName);
+            if (COMPOSITING_PROPERTIES.has(normalizedName)) {
+                // Special case for opacity - only warn if it's animated or fractional
+                if (normalizedName === 'opacity') {
+                    if (!propertyValue)
+                        return false;
+                    const numValue = Number.parseFloat(propertyValue);
+                    if (Number.isNaN(numValue))
+                        return false;
+                    return numValue > 0 && numValue < 1;
+                }
+                return true;
+            }
+            if (propertyValue && checkPropertyValue(propertyValue)) {
+                return true;
+            }
+            return false;
+        }
+        function checkNode(node) {
+            // Skip if we've already processed this node
+            if (seenNodes.has(node))
+                return;
+            seenNodes.add(node);
+            let propertyName = '';
+            let propertyValue = '';
+            // Get property name
+            if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                propertyName = node.key.name;
+            }
+            else if (node.key.type === utils_1.AST_NODE_TYPES.Literal) {
+                propertyName = String(node.key.value);
+            }
+            // Get property value if it's a string literal or numeric literal
+            if (node.value.type === utils_1.AST_NODE_TYPES.Literal) {
+                propertyValue = String(node.value.value);
+            }
+            if (checkProperty(propertyName, propertyValue)) {
+                context.report({
+                    node,
+                    messageId: 'compositingLayer',
+                    data: {
+                        property: propertyName,
+                    },
+                });
+            }
+        }
+        return {
+            // Handle object literal properties (inline styles)
+            Property(node) {
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                    return;
+                checkNode(node);
+            },
+            // Handle JSX style attributes
+            JSXAttribute(node) {
+                if (node.name.name !== 'style')
+                    return;
+                if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    node.value.expression.properties.forEach((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            checkNode(prop);
+                        }
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-compositing-layer-props.js.map

package/lib/rules/prefer-settings-object.d.ts

@@ -0,0 +1,11 @@
+type MessageIds = 'tooManyParams' | 'sameTypeParams';
+type Options = [
+    {
+        minimumParameters?: number;
+        checkSameTypeParameters?: boolean;
+        ignoreBoundMethods?: boolean;
+        ignoreVariadicFunctions?: boolean;
+    }
+];
+export declare const preferSettingsObject: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/prefer-settings-object.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferSettingsObject = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = {
+    minimumParameters: 3,
+    checkSameTypeParameters: true,
+    ignoreBoundMethods: true,
+    ignoreVariadicFunctions: true,
+};
+exports.preferSettingsObject = (0, createRule_1.createRule)({
+    name: 'prefer-settings-object',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using a settings object for functions with multiple parameters',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    minimumParameters: {
+                        type: 'number',
+                        minimum: 2,
+                    },
+                    checkSameTypeParameters: {
+                        type: 'boolean',
+                    },
+                    ignoreBoundMethods: {
+                        type: 'boolean',
+                    },
+                    ignoreVariadicFunctions: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            tooManyParams: 'Function has too many parameters ({{count}}). Use a settings object instead.',
+            sameTypeParams: 'Function has multiple parameters of the same type. Use a settings object instead.',
+        },
+    },
+    defaultOptions: [defaultOptions],
+    create(context, [options]) {
+        const finalOptions = { ...defaultOptions, ...options };
+        function getParameterType(param) {
+            if (param.type === utils_1.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+                const typeNode = param.typeAnnotation.typeAnnotation;
+                if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                    return typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? typeNode.typeName.name
+                        : 'unknown';
+                }
+                return typeNode.type;
+            }
+            return 'unknown';
+        }
+        function hasSameTypeParameters(params) {
+            const typeMap = new Map();
+            for (const param of params) {
+                const type = getParameterType(param);
+                typeMap.set(type, (typeMap.get(type) || 0) + 1);
+                if (typeMap.get(type) > 1) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function shouldIgnoreNode(node) {
+            // Ignore variadic functions if configured
+            if (finalOptions.ignoreVariadicFunctions) {
+                const hasRestParam = node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+                    node.params.some(param => param.type === utils_1.AST_NODE_TYPES.RestElement);
+                if (hasRestParam)
+                    return true;
+            }
+            // Ignore bound methods if configured
+            if (finalOptions.ignoreBoundMethods) {
+                let parent = node.parent;
+                while (parent) {
+                    if (parent.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                        parent.type === utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration) {
+                        return true;
+                    }
+                    parent = parent.parent;
+                }
+            }
+            return false;
+        }
+        function checkFunction(node) {
+            if (shouldIgnoreNode(node))
+                return;
+            const params = node.params;
+            // Check for too many parameters
+            const minParams = finalOptions.minimumParameters !== undefined
+                ? finalOptions.minimumParameters
+                : defaultOptions.minimumParameters;
+            if (params.length >= minParams) {
+                context.report({
+                    node,
+                    messageId: 'tooManyParams',
+                    data: { count: params.length },
+                });
+                return;
+            }
+            // Check for same type parameters if enabled
+            if (finalOptions.checkSameTypeParameters && params.length >= 2) {
+                if (hasSameTypeParameters(params)) {
+                    context.report({
+                        node,
+                        messageId: 'sameTypeParams',
+                    });
+                }
+            }
+        }
+        return {
+            FunctionDeclaration: checkFunction,
+            FunctionExpression: checkFunction,
+            ArrowFunctionExpression: checkFunction,
+            TSMethodSignature: checkFunction,
+            TSFunctionType: checkFunction,
+        };
+    },
+});
+//# sourceMappingURL=prefer-settings-object.js.map

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

@@ -7,6 +7,7 @@ module.exports = (0, createRule_1.createRule)({
         docs: {
             description: 'Enforce using ImageOverlayed component instead of next/image or img tags',
             recommended: 'error',
+            requiresTypeChecking: false,
         },
         fixable: 'code',
         schema: [
@@ -15,6 +16,7 @@ module.exports = (0, createRule_1.createRule)({
                 properties: {
                     componentPath: {
                         type: 'string',
+                        description: 'The import path for the ImageOverlayed component',
                         default: 'src/components/ImageOverlayed',
                     },
                 },

package/lib/rules/use-custom-memo.d.ts

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

package/lib/rules/use-custom-memo.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCustomMemo = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.useCustomMemo = (0, createRule_1.createRule)({
+    name: 'use-custom-memo',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using src/util/memo instead of React memo',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useCustomMemo: 'Import memo from src/util/memo instead of react',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'react') {
+                    const specifiers = node.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        specifier.imported.name === 'memo');
+                    if (specifiers.length > 0) {
+                        context.report({
+                            node,
+                            messageId: 'useCustomMemo',
+                            fix(fixer) {
+                                // If there are other imports from react, keep them
+                                const otherSpecifiers = node.specifiers.filter((specifier) => specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+                                    (specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                        specifier.imported.name !== 'memo'));
+                                if (otherSpecifiers.length === 0) {
+                                    // If memo is the only import, replace the entire import
+                                    return fixer.replaceText(node, `import { ${specifiers
+                                        .map((s) => s.local.name !== s.imported.name
+                                        ? `memo as ${s.local.name}`
+                                        : 'memo')
+                                        .join(', ')} } from 'src/util/memo';`);
+                                }
+                                else {
+                                    // Create a new import for memo and keep other imports
+                                    const memoImport = `import { ${specifiers
+                                        .map((s) => s.local.name !== s.imported.name
+                                        ? `memo as ${s.local.name}`
+                                        : 'memo')
+                                        .join(', ')} } from 'src/util/memo';\n`;
+                                    const otherImports = `import { ${otherSpecifiers
+                                        .map((s) => s.local.name)
+                                        .join(', ')} } from 'react';`;
+                                    return fixer.replaceText(node, memoImport + otherImports);
+                                }
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=use-custom-memo.js.map

package/lib/utils/ASTHelpers.js

@@ -91,6 +91,20 @@ class ASTHelpers {
                 return node.expressions.some((expr) => this.declarationIncludesIdentifier(expr));
             case 'TSAsExpression':
                 return this.declarationIncludesIdentifier(node.expression);
+            case 'TSTypeReference':
+                // Handle type references (e.g., T in generic types)
+                return false;
+            case 'TSTypeParameterDeclaration':
+                // Handle type parameter declarations (e.g., <T extends ...>)
+                return false;
+            case 'TSTypeParameterInstantiation':
+                // Handle type parameter instantiations (e.g., <string>)
+                return false;
+            case 'TSIntersectionType':
+            case 'TSUnionType':
+            case 'TSTypeLiteral':
+                // Handle type constraints and literals
+                return false;
             default:
                 return false;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.1.9",
+  "version": "1.2.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",