@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

package/lib/rules/enforce-date-ttime.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceDateTTime = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
+const createRule_1 = require("../utils/createRule");
+exports.enforceDateTTime = (0, createRule_1.createRule)({
+    name: 'enforce-date-ttime',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce that any generic type parameter named TTime is explicitly set to Date in frontend code',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            enforceDateTTime: '{{typeName}} leaves TTime unspecified or not Date → Firestore Frontend Hooks convert Timestamp to Date on the client, so non-Date TTime misrepresents runtime values and forces defensive conversions → Set the TTime argument to Date explicitly (e.g., {{typeName}}<..., Date, ...>).',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const parserServices = sourceCode?.parserServices ?? context.parserServices;
+        const checker = parserServices?.program?.getTypeChecker();
+        if (!parserServices || !checker) {
+            return {};
+        }
+        const tTimeIndexCache = new WeakMap();
+        /**
+         * Finds the index of the TTime parameter in the given symbol's declarations.
+         */
+        function findTTimeParameterIndex(symbol) {
+            if (tTimeIndexCache.has(symbol)) {
+                return tTimeIndexCache.get(symbol);
+            }
+            const declarations = symbol.getDeclarations();
+            if (!declarations) {
+                tTimeIndexCache.set(symbol, undefined);
+                return undefined;
+            }
+            for (const declaration of declarations) {
+                if (ts.isTypeAliasDeclaration(declaration) ||
+                    ts.isInterfaceDeclaration(declaration) ||
+                    ts.isClassDeclaration(declaration)) {
+                    if (declaration.typeParameters) {
+                        const index = declaration.typeParameters.findIndex((tp) => tp.name.text === 'TTime');
+                        if (index !== -1) {
+                            tTimeIndexCache.set(symbol, index);
+                            return index;
+                        }
+                    }
+                }
+            }
+            tTimeIndexCache.set(symbol, undefined);
+            return undefined;
+        }
+        /**
+         * Checks if a type node is exactly "Date".
+         */
+        function isExactDate(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.typeName.name === 'Date' &&
+                (!node.typeParameters || node.typeParameters.params.length === 0)) {
+                return true;
+            }
+            return false;
+        }
+        return {
+            TSTypeReference(node) {
+                const typeNameNode = node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName
+                    ? node.typeName.right
+                    : node.typeName;
+                if (typeNameNode.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                // Skip the "Date" type itself
+                if (typeNameNode.name === 'Date')
+                    return;
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                const symbol = checker.getSymbolAtLocation(tsNode.typeName);
+                if (!symbol)
+                    return;
+                const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias
+                    ? checker.getAliasedSymbol(symbol)
+                    : symbol;
+                const tTimeIndex = findTTimeParameterIndex(resolvedSymbol);
+                if (tTimeIndex === undefined)
+                    return;
+                const typeArgs = node.typeParameters?.params || [];
+                const tTimeArg = typeArgs[tTimeIndex];
+                const typeName = sourceCode.getText(node.typeName);
+                if (!tTimeArg) {
+                    // TTime is omitted
+                    context.report({
+                        node,
+                        messageId: 'enforceDateTTime',
+                        data: { typeName },
+                        fix(fixer) {
+                            if (node.typeParameters) {
+                                // Already has type parameters, but not enough to cover TTime
+                                const lastParam = node.typeParameters.params[node.typeParameters.params.length - 1];
+                                // Check if we can just append ", Date"
+                                // We can only do this safely if all parameters between existing ones and TTime have defaults.
+                                // For simplicity and safety, we only fix if tTimeIndex is the next one or if it's already provided.
+                                if (tTimeIndex === node.typeParameters.params.length) {
+                                    return fixer.insertTextAfter(lastParam, ', Date');
+                                }
+                            }
+                            else if (tTimeIndex === 0) {
+                                // No type parameters and TTime is the first one
+                                return fixer.insertTextAfter(node.typeName, '<Date>');
+                            }
+                            return null;
+                        },
+                    });
+                }
+                else if (!isExactDate(tTimeArg)) {
+                    // TTime is provided but is not exactly Date
+                    context.report({
+                        node: tTimeArg,
+                        messageId: 'enforceDateTTime',
+                        data: { typeName },
+                        fix(fixer) {
+                            return fixer.replaceText(tTimeArg, 'Date');
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-date-ttime.js.map

package/lib/rules/enforce-dynamic-firebase-imports.d.ts

@@ -1,4 +1,5 @@
 import { TSESTree } from '@typescript-eslint/utils';
-export declare const enforceFirebaseImports: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noDynamicImport", never[], {
+declare const enforceFirebaseImports: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noDynamicImport", never[], {
     ImportDeclaration(node: TSESTree.ImportDeclaration): void;
 }>;
+export default enforceFirebaseImports;

package/lib/rules/enforce-dynamic-firebase-imports.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enforceFirebaseImports = void 0;
 const createRule_1 = require("../utils/createRule");
-exports.enforceFirebaseImports = (0, createRule_1.createRule)({
+const enforceFirebaseImports = (0, createRule_1.createRule)({
     name: 'enforce-dynamic-firebase-imports',
     meta: {
         type: 'problem',
@@ -112,6 +111,7 @@ exports.enforceFirebaseImports = (0, createRule_1.createRule)({
                     suggest: [
                         {
                             messageId: 'noDynamicImport',
+                            data: { importPath },
                             fix(fixer) {
                                 const replacement = buildReplacement({
                                     allowSideEffectFix: true,
@@ -127,4 +127,5 @@ exports.enforceFirebaseImports = (0, createRule_1.createRule)({
         };
     },
 });
+exports.default = enforceFirebaseImports;
 //# sourceMappingURL=enforce-dynamic-firebase-imports.js.map

package/lib/rules/enforce-dynamic-imports.d.ts

@@ -1,9 +1,10 @@
 export declare const RULE_NAME = "enforce-dynamic-imports";
 type Options = [
     {
-        libraries: string[];
+        ignoredLibraries?: string[];
         allowImportType?: boolean;
     }
 ];
+export declare const DEFAULT_IGNORED_LIBRARIES: string[];
 declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"dynamicImportRequired", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export default _default;

package/lib/rules/enforce-dynamic-imports.js

@@ -1,21 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RULE_NAME = void 0;
+exports.DEFAULT_IGNORED_LIBRARIES = exports.RULE_NAME = void 0;
 const createRule_1 = require("../utils/createRule");
+const minimatch_1 = require("minimatch");
 exports.RULE_NAME = 'enforce-dynamic-imports';
+exports.DEFAULT_IGNORED_LIBRARIES = [
+    'react',
+    'react/**',
+    'react-dom',
+    'react-dom/**',
+    'next',
+    'next/**',
+    '@mui/material',
+    '@mui/material/**',
+    '@mui/icons-material',
+    '@mui/icons-material/**',
+    '@emotion/**',
+    'clsx',
+    'tailwind-merge',
+];
 exports.default = (0, createRule_1.createRule)({
     name: exports.RULE_NAME,
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce dynamic imports for specified libraries to optimize bundle size',
+            description: 'Enforce dynamic imports for external libraries by default to optimize bundle size, unless explicitly ignored',
             recommended: 'error',
         },
         schema: [
             {
                 type: 'object',
                 properties: {
-                    libraries: {
+                    ignoredLibraries: {
                         type: 'array',
                         items: {
                             type: 'string',
@@ -29,46 +45,51 @@ exports.default = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            dynamicImportRequired: 'Static import from "{{source}}" eagerly pulls the entire package into the entry bundle, inflating download size and delaying the first render. Load it lazily with a dynamic import (for example, useDynamic(() => import("{{source}}"))) so the code is fetched only when needed; if you only need types, use a type-only import with allowImportType enabled.',
+            dynamicImportRequired: 'Static import from "{{source}}" loads the full package into the initial bundle. → This increases download size and delays first render, undermining our lazy‑loading pattern for external dependencies. → Use a dynamic import (e.g., useDynamic(() => import("{{source}}"))), add "{{source}}" to ignoredLibraries for intentional static usage, or use a type‑only import when you only need types.',
         },
     },
     defaultOptions: [
         {
-            libraries: ['@stream-io/video-react-sdk'],
+            ignoredLibraries: exports.DEFAULT_IGNORED_LIBRARIES,
             allowImportType: true,
         },
     ],
     create(context, [options]) {
-        const { libraries, allowImportType = true } = options;
-        // Check if the import source matches any of the specified libraries
-        const isLibraryMatch = (source) => {
-            return libraries.some((lib) => {
-                // Simple glob pattern matching
-                if (lib.includes('*')) {
-                    const pattern = lib.replace(/\*/g, '.*');
-                    const regex = new RegExp(`^${pattern}$`);
-                    return regex.test(source);
-                }
-                return source === lib;
-            });
+        const { ignoredLibraries = exports.DEFAULT_IGNORED_LIBRARIES, allowImportType = true, } = options;
+        const exactIgnored = new Set();
+        const globIgnored = [];
+        for (const lib of ignoredLibraries) {
+            const mm = new minimatch_1.Minimatch(lib);
+            if (mm.hasMagic()) {
+                globIgnored.push(mm);
+            }
+            else {
+                exactIgnored.add(lib);
+            }
+        }
+        const isIgnored = (source) => {
+            return (exactIgnored.has(source) ||
+                globIgnored.some((mm) => mm.match(source)));
+        };
+        const isExternal = (source) => {
+            // Treat npm-style specifiers (including numeric names like '3d-force-graph') as external; internal paths are excluded.
+            return /^[a-z0-9@]/i.test(source) && !source.startsWith('@/');
         };
         return {
             ImportDeclaration(node) {
                 const importSource = node.source.value;
                 // Skip type-only imports if allowed
                 if (allowImportType) {
-                    // Check if it's a type-only import declaration
                     if (node.importKind === 'type') {
                         return;
                     }
-                    // Check if all specifiers are type imports
                     if (node.specifiers.length > 0 &&
                         node.specifiers.every((spec) => spec.type === 'ImportSpecifier' && spec.importKind === 'type')) {
                         return;
                     }
                 }
-                // Check if the import is from a library that should be dynamically imported
-                if (typeof importSource === 'string' && isLibraryMatch(importSource)) {
+                // Only enforce for external libraries that are NOT ignored
+                if (isExternal(importSource) && !isIgnored(importSource)) {
                     context.report({
                         node,
                         messageId: 'dynamicImportRequired',

package/lib/rules/enforce-f-extension-for-entry-points.d.ts

@@ -0,0 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type EnforceFExtensionOptions = [
+    {
+        entryPoints?: string[];
+    }
+];
+export declare const enforceFExtensionForEntryPoints: TSESLint.RuleModule<"requireFExtension", EnforceFExtensionOptions, TSESLint.RuleListener>;
+export {};

package/lib/rules/enforce-f-extension-for-entry-points.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceFExtensionForEntryPoints = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const path_1 = __importDefault(require("path"));
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const DEFAULT_ENTRY_POINTS = [
+    'onCall',
+    'onCallVaripotent',
+    'onRequest',
+    'onQueueTask',
+    'onWebhook',
+    'sequentialDocumentWritten',
+    'onDocumentWritten',
+    'onDocumentCreated',
+    'onDocumentDeleted',
+    'onDocumentUpdated',
+    'onSchedule',
+    'onValueWritten',
+    'onValueCreated',
+    'onValueUpdated',
+    'onValueDeleted',
+    'sequentialValueWritten',
+    'sequentialValueCreated',
+    'sequentialValueUpdated',
+    'sequentialValueDeleted',
+];
+/**
+ * Entry points must be defined at the top level because Firebase deployment
+ * discovers and registers them by evaluating the module scope. Nested definitions
+ * inside functions or classes won't be discovered during the deployment process.
+ */
+function isTopLevel(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.ClassExpression ||
+            current.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+            return false;
+        }
+        current = current.parent;
+    }
+    return true;
+}
+/**
+ * Checks if a node directly defines an entry point as a function or variable declaration.
+ * This exempts wrapper implementation files (e.g., functions/src/v2/) but intentionally
+ * does not exempt re-export files (e.g., `const myCall = onCall; export { myCall }`).
+ * Re-export files that also invoke entry points must still follow the .f.ts naming convention
+ * and will be flagged by the CallExpression handler.
+ *
+ * This function specifically checks AST node types FunctionDeclaration and
+ * VariableDeclaration but does not catch ExportSpecifiers used in re-exports.
+ */
+function isNodeDefiningEntryPoint(node, entryPoints) {
+    // Handle function declaration: export function onCall() {}
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+        node.id &&
+        entryPoints.has(node.id.name)) {
+        return true;
+    }
+    // Handle variable declaration: export const onCall = ...
+    if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+        return node.declarations.some((decl) => decl.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+            entryPoints.has(decl.id.name));
+    }
+    return false;
+}
+/**
+ * Obtains the scope for a node in an ESLint 9+ compatible way.
+ *
+ * Note: In ESLint 8, falls back to context.getScope() which returns the scope
+ * of the currently visited node—only call this from within visitor handlers
+ * for the target node.
+ */
+function getScopeForNode(context, node) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    if (isEslint9OrLater(sourceCode)) {
+        return getEslint9Scope(sourceCode, node);
+    }
+    return context.getScope();
+}
+/**
+ * Checks if the current environment is ESLint 9 or later.
+ */
+function isEslint9OrLater(sourceCode) {
+    return typeof sourceCode.getScope === 'function';
+}
+/**
+ * Gets the scope for a node using the ESLint 9+ SourceCode.getScope() method.
+ */
+function getEslint9Scope(sourceCode, node) {
+    return sourceCode.getScope(node);
+}
+/**
+ * Gets the import definition for a given name in the current scope.
+ */
+function getImportDef(context, calleeName, node) {
+    const scope = getScopeForNode(context, node);
+    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, calleeName);
+    if (!variable) {
+        return null;
+    }
+    return variable.defs.find((def) => def.type === 'ImportBinding') ?? null;
+}
+/**
+ * Checks if the import comes from an allowed Firebase or internal wrapper source.
+ */
+function isFromAllowedSource(importDef) {
+    if (!importDef || !importDef.parent) {
+        return false;
+    }
+    const importDeclaration = importDef.parent;
+    if (importDeclaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+        return false;
+    }
+    const source = importDeclaration.source.value;
+    return (source.startsWith('firebase-functions') ||
+        /(^|\/)v2(\/|$)/.test(source) ||
+        /(^|\/)util\/webhook(\/|$)/.test(source));
+}
+/**
+ * Helper function to extract name from import specifier.
+ */
+function getNameFromImportSpecifier(node) {
+    const { imported } = node;
+    if (imported.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return imported.name;
+    }
+    // Handle Literal imports (string-named imports in ESLint 8+)
+    const importedNode = imported;
+    if (importedNode.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof importedNode.value === 'string') {
+        return importedNode.value;
+    }
+    return undefined;
+}
+/**
+ * Helper function to extract name from module path.
+ */
+function getNameFromModulePath(importDeclaration, entryPoints) {
+    const modulePath = importDeclaration.source.value;
+    // Extract the module name from the path.
+    // Example: '../../v2/https/onCall' -> 'onCall'
+    const match = modulePath.match(/[/\\]([^/\\]+)$/);
+    const segment = (match ? match[1] : modulePath).replace(/\.[jt]sx?$/, '');
+    return entryPoints.has(segment) ? segment : undefined;
+}
+/**
+ * Resolves the original name of the imported function, handling aliases and default imports.
+ */
+function getOriginalName(importDef, calleeName, entryPoints) {
+    if (!importDef || !importDef.node) {
+        return calleeName;
+    }
+    // Handle named imports: import { onCall as myCall } from ...
+    if (importDef.node.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+        return getNameFromImportSpecifier(importDef.node) ?? calleeName;
+    }
+    // Handle default imports: import onCall from '../../v2/https/onCall'
+    // or namespace imports: import * as onCall from '../../v2/https/onCall'
+    if (importDef.node.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        importDef.node.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return (getNameFromModulePath(importDef.parent, entryPoints) ?? calleeName);
+    }
+    return calleeName;
+}
+exports.enforceFExtensionForEntryPoints = (0, createRule_1.createRule)({
+    name: 'enforce-f-extension-for-entry-points',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce .f.ts extension for entry points',
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    entryPoints: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requireFExtension: 'File "{{fileName}}" contains a Firebase Cloud Function entry point "{{entryPoint}}" but lacks the ".f.ts" extension. ' +
+                'Entry points must use ".f.ts" to clearly mark the public function surface to avoid accidental export/name collisions, ' +
+                'unintended exposure of internal implementation during deployment, confusion during imports/tests, and maintenance bugs. ' +
+                'Rename this file to "{{suggestedName}}" to mark it as a public entry point.',
+        },
+    },
+    defaultOptions: [{ entryPoints: DEFAULT_ENTRY_POINTS }],
+    create(context, [options]) {
+        const filePath = context.filename ??
+            context.getFilename();
+        const fileName = path_1.default.basename(filePath);
+        const entryPoints = new Set(options.entryPoints?.length ? options.entryPoints : DEFAULT_ENTRY_POINTS);
+        // Only apply to files under functions/src/
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        if (!normalizedPath.includes('/functions/src/') &&
+            !normalizedPath.startsWith('functions/src/')) {
+            return {};
+        }
+        // Exclude test files and declaration files
+        if (/\.(test|spec)\.tsx?$|\.d\.ts$/.test(fileName)) {
+            return {};
+        }
+        // Only apply to .ts and .tsx files, but not files already using .f.ts or .f.tsx
+        const isTsOrTsx = /\.tsx?$/.test(fileName);
+        const isFExtension = /\.f\.tsx?$/.test(fileName);
+        if (!isTsOrTsx || isFExtension) {
+            return {};
+        }
+        let isDefiningEntryPoint = false;
+        let reported = false;
+        return {
+            ExportNamedDeclaration(node) {
+                if (isDefiningEntryPoint || !node.declaration) {
+                    return;
+                }
+                if (isNodeDefiningEntryPoint(node.declaration, entryPoints)) {
+                    isDefiningEntryPoint = true;
+                }
+            },
+            ExportDefaultDeclaration(node) {
+                if (isDefiningEntryPoint) {
+                    return;
+                }
+                if (isNodeDefiningEntryPoint(node.declaration, entryPoints)) {
+                    isDefiningEntryPoint = true;
+                }
+            },
+            CallExpression(node) {
+                if (reported || isDefiningEntryPoint) {
+                    return;
+                }
+                // We only care about simple identifier calls (e.g., onCall())
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const calleeName = node.callee.name;
+                // Optimization: Early return if it's not a top-level call
+                if (!isTopLevel(node)) {
+                    return;
+                }
+                // Variable lookup logic and import source validation
+                const importDef = getImportDef(context, calleeName, node);
+                if (!importDef || !isFromAllowedSource(importDef)) {
+                    return;
+                }
+                // Entry point checking
+                const originalName = getOriginalName(importDef, calleeName, entryPoints);
+                if (!entryPoints.has(originalName)) {
+                    return;
+                }
+                reported = true;
+                const suggestedName = fileName.replace(/\.tsx?$/, '.f$&');
+                context.report({
+                    node,
+                    messageId: 'requireFExtension',
+                    data: {
+                        fileName,
+                        entryPoint: calleeName === originalName
+                            ? calleeName
+                            : `${calleeName} (${originalName})`,
+                        suggestedName,
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-f-extension-for-entry-points.js.map

package/lib/rules/enforce-global-constants.js

@@ -9,14 +9,14 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using global static constants instead of useMemo with empty dependency arrays for object literals, and extract inline destructuring defaults in React components/hooks to global constants',
+            description: 'Enforce global static constants for React components/hooks',
             recommended: 'error',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            useGlobalConstant: 'Use a global static constant instead of useMemo with an empty dependency array for object literals',
-            extractDefaultToGlobalConstant: 'Extract inline default value to a module-level constant for stable reference',
+            useGlobalConstant: 'Object literal returned from useMemo with empty dependencies creates a new reference every render without providing memoization benefits → this wastes memory and misleads readers into thinking the value is computed → move the object to a module-level constant (e.g., const OPTIONS = { ... } as const;).',
+            extractDefaultToGlobalConstant: 'Inline default value in destructuring creates a new reference on every render → this causes unnecessary re-renders in child components due to unstable identity → extract the default to a module-level constant (e.g., const DEFAULT_OPTIONS = { ... } as const;).',
         },
     },
     defaultOptions: [],

package/lib/rules/enforce-id-capitalization.js

@@ -19,7 +19,7 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            enforceIdCapitalization: 'Use "ID" instead of "id" in user-facing text for better readability',
+            enforceIdCapitalization: 'Found lowercase "id" in user-facing text → "ID" (capitalized) is the standard abbreviation for "identifier" and improves readability in UI labels and messages → replace lowercase "id" with uppercase "ID" in displayed labels and messages.',
         },
     },
     defaultOptions: [],