@blumintinc/eslint-plugin-blumint 1.15.0 → 1.16.1

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -33,6 +33,14 @@ const DEFAULT_BOOLEAN_PREFIXES = [
 const DEFAULT_OPTIONS = {
     prefixes: DEFAULT_BOOLEAN_PREFIXES,
     ignoreOverriddenGetters: false,
+    // Property names declared in interfaces and type aliases are frequently
+    // dictated by contracts the author cannot rename: external API request/response
+    // shapes, third-party library interfaces, and persisted data-model schemas
+    // (e.g. Firestore document fields). Flagging those produces unavoidable false
+    // positives, so property-signature enforcement is opt-in. Names the author does
+    // choose freshly — variables, function returns, class fields, parameters — stay
+    // enforced by default.
+    enforceForPropertySignatures: false,
 };
 const BOOLEANISH_BINARY_OPERATORS = new Set(['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof']);
 exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
@@ -58,6 +66,10 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                         type: 'boolean',
                         default: false,
                     },
+                    enforceForPropertySignatures: {
+                        type: 'boolean',
+                        default: false,
+                    },
                 },
                 additionalProperties: false,
             },
@@ -71,8 +83,11 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
     defaultOptions: [DEFAULT_OPTIONS],
     create(context, [options]) {
         const approvedPrefixes = options.prefixes || DEFAULT_OPTIONS.prefixes;
+        const approvedPrefixesWithoutAsserts = approvedPrefixes.filter((p) => p !== 'asserts');
         const ignoreOverriddenGetters = options.ignoreOverriddenGetters ??
             DEFAULT_OPTIONS.ignoreOverriddenGetters;
+        const enforceForPropertySignatures = options.enforceForPropertySignatures ??
+            DEFAULT_OPTIONS.enforceForPropertySignatures;
         function findVariableInScopes(name) {
             let currentScope = context.getScope();
             while (currentScope) {
@@ -83,32 +98,58 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             }
             return undefined;
         }
+        /**
+         * Check if a name is prefixed by a boolean keyword with proper boundaries.
+         * Supports camelCase (isSomething), snake_case (is_something, IS_SOMETHING),
+         * and exact matches.
+         */
+        function isPrefixedByBooleanKeyword(name, prefixes) {
+            const normalizedName = name.startsWith('_') ? name.slice(1) : name;
+            const checkPrefix = (p) => {
+                if (!normalizedName.toLowerCase().startsWith(p.toLowerCase())) {
+                    return false;
+                }
+                if (normalizedName.length === p.length) {
+                    return true;
+                }
+                const nextChar = normalizedName.charAt(p.length);
+                // For SCREAMING_SNAKE_CASE or similar all-uppercase names,
+                // we require an underscore boundary.
+                const isAllUppercase = normalizedName === normalizedName.toUpperCase() &&
+                    /[a-z]/i.test(normalizedName);
+                if (isAllUppercase) {
+                    return nextChar === '_';
+                }
+                // For camelCase, the next char must be uppercase, a digit, or $
+                return (nextChar === '_' ||
+                    nextChar === '$' ||
+                    (nextChar >= '0' && nextChar <= '9') ||
+                    (nextChar === nextChar.toUpperCase() &&
+                        nextChar !== nextChar.toLowerCase()));
+            };
+            const checkPrefixWithPlural = (p) => {
+                if (checkPrefix(p))
+                    return true;
+                if (['is', 'has', 'does', 'was', 'had', 'did'].includes(p)) {
+                    const pluralPrefix = pluralize_1.default.plural(p);
+                    if (checkPrefix(pluralPrefix))
+                        return true;
+                }
+                return false;
+            };
+            return prefixes.some((prefix) => checkPrefixWithPlural(prefix));
+        }
         /**
          * Check if a name starts with any of the approved prefixes, their plural forms,
          * or if it starts with an underscore (which indicates a private/internal property)
          */
         function hasApprovedPrefix(name, options) {
             const treatLeadingUnderscoreAsApproved = options?.treatLeadingUnderscoreAsApproved ?? true;
-            const normalizedName = name.startsWith('_') ? name.slice(1) : name;
             // Skip checking properties that start with an underscore (private/internal properties)
             if (treatLeadingUnderscoreAsApproved && name.startsWith('_')) {
                 return true;
             }
-            return approvedPrefixes.some((prefix) => {
-                // Check for exact prefix match
-                if (normalizedName.toLowerCase().startsWith(prefix.toLowerCase())) {
-                    return true;
-                }
-                // Check for plural form of the prefix
-                // Only apply pluralization to certain prefixes that have meaningful plural forms
-                if (['is', 'has', 'does', 'was', 'had', 'did'].includes(prefix)) {
-                    const pluralPrefix = pluralize_1.default.plural(prefix);
-                    return normalizedName
-                        .toLowerCase()
-                        .startsWith(pluralPrefix.toLowerCase());
-                }
-                return false;
-            });
+            return isPrefixedByBooleanKeyword(name, approvedPrefixes);
         }
         function nameSuggestsBoolean(name) {
             const normalizedName = name.startsWith('_') ? name.slice(1) : name;
@@ -125,9 +166,8 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 'authenticated',
                 'authorized',
             ];
-            return (hasApprovedPrefix(normalizedName, {
-                treatLeadingUnderscoreAsApproved: false,
-            }) || suffixKeywords.some((keyword) => lowerName.endsWith(keyword)));
+            return (isPrefixedByBooleanKeyword(normalizedName, approvedPrefixes) ||
+                suffixKeywords.some((keyword) => lowerName.endsWith(keyword)));
         }
         /**
          * Capitalize the first letter of a name for use in suggested alternatives
@@ -205,94 +245,20 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 // Check for logical expressions (&&)
                 if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
                     node.init.operator === '&&') {
-                    // Check if the right side is a method call that might return a non-boolean value
-                    const rightSide = node.init.right;
-                    if (rightSide.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                        // If right side is a simple identifier call
-                        if (rightSide.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            const calleeName = rightSide.callee.name;
-                            const lowerCallee = calleeName.toLowerCase();
-                            // For assert*-style utilities, only treat as boolean if we can confirm boolean return type
-                            if (lowerCallee.startsWith('assert')) {
-                                return identifierReturnsBoolean(calleeName);
-                            }
-                            // Otherwise, infer based on naming heuristics
-                            const isBooleanCall = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                                lowerCallee.startsWith(prefix.toLowerCase()));
-                            if (isBooleanCall ||
-                                lowerCallee.includes('boolean') ||
-                                lowerCallee.includes('enabled') ||
-                                lowerCallee.includes('auth') ||
-                                lowerCallee.includes('valid') ||
-                                lowerCallee.includes('check')) {
-                                return true;
-                            }
-                            if (lowerCallee.startsWith('get') ||
-                                lowerCallee.startsWith('fetch') ||
-                                lowerCallee.startsWith('retrieve') ||
-                                lowerCallee.startsWith('load') ||
-                                lowerCallee.startsWith('read')) {
-                                return false;
-                            }
-                        }
-                        // If the method name doesn't suggest it returns a boolean, don't flag it
-                        if (rightSide.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                            rightSide.callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            const methodName = rightSide.callee.property.name;
-                            const lowerMethodName = methodName.toLowerCase();
-                            // Ignore assert*-style methods which often return the input value
-                            if (lowerMethodName.startsWith('assert')) {
-                                return false;
-                            }
-                            // Check if the method name suggests it returns a boolean
-                            const isBooleanMethod = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                                lowerMethodName.startsWith(prefix.toLowerCase()));
-                            // If the method name suggests it returns a boolean (starts with a boolean prefix or contains 'boolean' or 'enabled'),
-                            // then the variable should be treated as a boolean
-                            if (isBooleanMethod ||
-                                lowerMethodName.includes('boolean') ||
-                                lowerMethodName.includes('enabled') ||
-                                lowerMethodName.includes('auth') ||
-                                lowerMethodName.includes('valid') ||
-                                lowerMethodName.includes('check')) {
-                                return true;
-                            }
-                            // For methods like getVolume(), getData(), etc., assume they return non-boolean values
-                            if (lowerMethodName.startsWith('get') ||
-                                lowerMethodName.startsWith('fetch') ||
-                                lowerMethodName.startsWith('retrieve') ||
-                                lowerMethodName.startsWith('load') ||
-                                lowerMethodName.startsWith('read')) {
-                                return false;
-                            }
-                        }
+                    const left = evaluateBooleanishExpression(node.init.left);
+                    const right = evaluateBooleanishExpression(node.init.right);
+                    // If both sides are boolean, the result is boolean.
+                    if (left === 'boolean' && right === 'boolean') {
+                        return true;
                     }
-                    // Check if the right side is a property access that might return a non-boolean value
-                    if (rightSide.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        rightSide.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const propertyName = rightSide.property.name;
-                        const lowerPropertyName = propertyName.toLowerCase();
-                        // If the property name is 'parentElement', 'parentNode', etc., it's likely not a boolean
-                        if (lowerPropertyName.includes('parent') ||
-                            lowerPropertyName.includes('element') ||
-                            lowerPropertyName.includes('node') ||
-                            lowerPropertyName.includes('child') ||
-                            lowerPropertyName.includes('sibling')) {
-                            return false;
-                        }
-                        // Ignore assert*-style properties which often return the input value
-                        if (lowerPropertyName.startsWith('assert')) {
-                            return false;
-                        }
-                        // For property access like user.isAuthenticated, treat as boolean
-                        const isBooleanProperty = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                            lowerPropertyName.startsWith(prefix.toLowerCase()));
-                        if (isBooleanProperty) {
-                            return true;
-                        }
+                    // If the right side is boolean, and the left side is unknown (but not non-boolean),
+                    // we treat it as boolean to avoid false negatives for common patterns like `user && user.isActive`.
+                    // This is a trade-off: it might cause some false positives for non-boolean variables
+                    // used as guards, but those are less common than the `user && user.isActive` pattern.
+                    if (right === 'boolean' && left === 'unknown') {
+                        return true;
                     }
-                    // Default to true for other cases with && to avoid false negatives
-                    return true;
+                    return false;
                 }
                 // Special case for logical OR (||) - only consider it boolean if:
                 // 1. It's used with boolean literals or
@@ -330,8 +296,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                         if (lowerCallee.startsWith('assert')) {
                             return identifierReturnsBoolean(calleeName);
                         }
-                        return approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                            lowerCallee.startsWith(prefix.toLowerCase()));
+                        return isPrefixedByBooleanKeyword(calleeName, approvedPrefixesWithoutAsserts);
                     }
                     // Default to false for other cases with || to avoid false positives
                     return false;
@@ -351,8 +316,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                         return identifierReturnsBoolean(calleeName);
                     }
                     // Check if the function name suggests it returns a boolean
-                    return approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                        lowerCallee.startsWith(prefix.toLowerCase()));
+                    return isPrefixedByBooleanKeyword(calleeName, approvedPrefixes.filter((p) => p !== 'asserts'));
                 }
             }
             return false;
@@ -435,8 +399,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 if (lowerCallee.startsWith('assert')) {
                     return identifierReturnsBoolean(calleeName) ? 'boolean' : 'unknown';
                 }
-                const matchesPrefix = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                    lowerCallee.startsWith(prefix.toLowerCase()));
+                const matchesPrefix = isPrefixedByBooleanKeyword(calleeName, approvedPrefixesWithoutAsserts);
                 if (matchesPrefix ||
                     lowerCallee.includes('boolean') ||
                     lowerCallee.includes('enabled') ||
@@ -460,8 +423,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 if (lowerMethodName.startsWith('assert')) {
                     return 'unknown';
                 }
-                const matchesPrefix = approvedPrefixes.some((prefix) => prefix !== 'asserts' &&
-                    lowerMethodName.startsWith(prefix.toLowerCase()));
+                const matchesPrefix = isPrefixedByBooleanKeyword(methodName, approvedPrefixesWithoutAsserts);
                 if (matchesPrefix ||
                     lowerMethodName.includes('boolean') ||
                     lowerMethodName.includes('enabled') ||
@@ -475,7 +437,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
         }
         function evaluateBooleanishExpression(expression) {
             if (!expression)
-                return 'nonBoolean';
+                return 'unknown';
             let currentExpression = expression;
             if (currentExpression.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
                 currentExpression.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
@@ -825,10 +787,10 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             });
         }
         /**
-         * Check if a variable is used in a while loop condition and is likely a boolean
+         * Check if a variable is initialized with a boolean-suggesting member expression
          * This helps identify variables that should be flagged as needing a boolean prefix
          */
-        function isLikelyBooleanInWhileLoop(node) {
+        function isLikelyBooleanByMemberExpression(node) {
             // Check if the variable is initialized with a boolean-related value
             const variableDeclarator = node.parent;
             if (variableDeclarator?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
@@ -844,7 +806,7 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     init.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                     const propertyName = init.property.name;
                     // If the property name suggests it's a boolean (starts with a boolean prefix)
-                    const isBooleanProperty = approvedPrefixes.some((prefix) => propertyName.toLowerCase().startsWith(prefix.toLowerCase()));
+                    const isBooleanProperty = isPrefixedByBooleanKeyword(propertyName, approvedPrefixes);
                     if (isBooleanProperty) {
                         return true;
                     }
@@ -895,8 +857,8 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 return;
             // Check if it's a boolean variable
             let isBooleanVar = hasBooleanTypeAnnotation(node.id) || hasInitialBooleanValue(node);
-            // Check if it's a boolean variable used in a while loop
-            if (!isBooleanVar && isLikelyBooleanInWhileLoop(node.id)) {
+            // Check if it's a boolean variable used in a while loop or initialized with a boolean property
+            if (!isBooleanVar && isLikelyBooleanByMemberExpression(node.id)) {
                 isBooleanVar = true;
             }
             // Check if it's an arrow function with boolean return type
@@ -1074,6 +1036,11 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
          * Check property signatures in interfaces/types for boolean types
          */
         function checkPropertySignature(node) {
+            // Interface/type-alias property names are commonly imposed by contracts the
+            // author cannot rename (external APIs, data-model schemas), so they are only
+            // enforced when explicitly opted in.
+            if (!enforceForPropertySignatures)
+                return;
             if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return;
             const propertyName = node.key.name;

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

@@ -1,9 +1,13 @@
 export declare const RULE_NAME = "enforce-dynamic-imports";
 type Options = [
     {
-        libraries: string[];
+        libraries?: string[];
+        ignoredLibraries?: string[];
+        internalPrefixes?: string[];
         allowImportType?: boolean;
     }
 ];
+export declare const DEFAULT_IGNORED_LIBRARIES: string[];
+export declare const DEFAULT_INTERNAL_PREFIXES: 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,14 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RULE_NAME = void 0;
+exports.DEFAULT_INTERNAL_PREFIXES = exports.DEFAULT_IGNORED_LIBRARIES = exports.RULE_NAME = void 0;
 const createRule_1 = require("../utils/createRule");
+const minimatch_1 = require("minimatch");
+const module_1 = require("module");
 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_INTERNAL_PREFIXES = ['src/', 'functions/'];
+// Pre-built set of Node.js core module names for O(1) lookup.
+const NODE_BUILTINS = new Set(module_1.builtinModules);
+// Returns true for any source that resolves to a Node builtin: bare name
+// ('crypto'), node:-prefixed ('node:fs'), or path form ('fs/promises').
+const isNodeBuiltin = (source) => source.startsWith('node:') ||
+    NODE_BUILTINS.has(source) ||
+    NODE_BUILTINS.has(source.split('/')[0]);
 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: [
@@ -21,6 +46,18 @@ exports.default = (0, createRule_1.createRule)({
                             type: 'string',
                         },
                     },
+                    ignoredLibraries: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    internalPrefixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
                     allowImportType: {
                         type: 'boolean',
                     },
@@ -29,46 +66,80 @@ 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,
+            internalPrefixes: exports.DEFAULT_INTERNAL_PREFIXES,
             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);
+        const { libraries, ignoredLibraries = exports.DEFAULT_IGNORED_LIBRARIES, internalPrefixes = exports.DEFAULT_INTERNAL_PREFIXES, allowImportType = true, } = options;
+        // When `libraries` is provided, the rule operates in whitelist mode:
+        // only the explicitly listed libraries are enforced. This preserves
+        // backwards-compatibility with pre-1.16.0 consumer configurations.
+        // When `libraries` is absent, enforce-by-default mode applies:
+        // all external imports are flagged unless in `ignoredLibraries`.
+        const isWhitelistMode = libraries !== undefined;
+        // Build an O(1) + glob matcher from a list of library patterns.
+        const buildMatcher = (list) => {
+            const exactSet = new Set();
+            const globs = [];
+            for (const lib of list) {
+                const mm = new minimatch_1.Minimatch(lib);
+                if (mm.hasMagic()) {
+                    globs.push(mm);
+                }
+                else {
+                    exactSet.add(lib);
                 }
-                return source === lib;
-            });
+            }
+            return (source) => exactSet.has(source) || globs.some((mm) => mm.match(source));
+        };
+        // In whitelist mode, `libraries` is defined (checked above). In
+        // enforce-by-default mode, `ignoredLibraries` is used instead.
+        const isListedInWhitelist = buildMatcher(libraries ?? []);
+        const isIgnoredLibrary = buildMatcher(ignoredLibraries);
+        // A source is external only if it looks like an npm package specifier AND
+        // is not a known-internal path. Node builtins and configured internal
+        // prefixes (e.g. src/, functions/) are excluded to avoid false positives
+        // on TypeScript baseUrl imports and Node core modules.
+        const isExternal = (source) => {
+            return (/^[a-z0-9@]/i.test(source) &&
+                !source.startsWith('@/') &&
+                !isNodeBuiltin(source) &&
+                !internalPrefixes.some((prefix) => source.startsWith(prefix)));
         };
         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)) {
+                let shouldReport;
+                if (isWhitelistMode) {
+                    // Whitelist mode: report only if the source matches an explicitly
+                    // listed library. External detection and ignoredLibraries are not
+                    // consulted, so unlisted npm packages are silently allowed.
+                    shouldReport = isListedInWhitelist(importSource);
+                }
+                else {
+                    // Enforce-by-default mode: report if the source is an external
+                    // package and is not in the ignored list.
+                    shouldReport =
+                        isExternal(importSource) && !isIgnoredLibrary(importSource);
+                }
+                if (shouldReport) {
                     context.report({
                         node,
                         messageId: 'dynamicImportRequired',

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

@@ -4,10 +4,7 @@ exports.enforceMemoizeAsync = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const MEMOIZE_MODULE = '@blumintinc/typescript-memoize';
-const ALLOWED_MEMOIZE_MODULES = new Set([
-    MEMOIZE_MODULE,
-    'typescript-memoize',
-]);
+const ALLOWED_MEMOIZE_MODULES = new Set([MEMOIZE_MODULE, 'typescript-memoize']);
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()

package/lib/rules/enforce-mui-rounded-icons.js

@@ -3,6 +3,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMuiRoundedIcons = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Non-Rounded MUI variant suffixes. An icon imported as one of these variants
+ * (e.g. `AddReactionOutlined`) maps to the Rounded variant of its BASE name
+ * (`AddReactionRounded`), not `AddReactionOutlinedRounded` (which doesn't exist).
+ * Matched exactly, so a distinct icon like `MailOutline` (ends in "Outline", not
+ * "Outlined") is left intact → `MailOutlineRounded`, which does exist.
+ */
+const VARIANT_SUFFIXES = ['Outlined', 'Sharp', 'TwoTone'];
+/**
+ * @mui/icons-material brand icons that ship in a single (Filled) variant only —
+ * they have no Rounded counterpart, so the rule must not demand one. Computed
+ * from @mui/icons-material (the only base icons lacking a `*Rounded` sibling).
+ */
+const ICONS_WITHOUT_ROUNDED = new Set([
+    'Apple',
+    'GitHub',
+    'Google',
+    'Instagram',
+    'LinkedIn',
+    'Microsoft',
+    'Pinterest',
+    'Reddit',
+    'Telegram',
+    'Twitter',
+    'WhatsApp',
+    'X',
+    'YouTube',
+]);
+/** Strips a trailing non-Rounded variant suffix to recover the base icon name. */
+const toBaseIconName = (iconName) => {
+    const suffix = VARIANT_SUFFIXES.find((variant) => iconName.endsWith(variant));
+    return suffix ? iconName.slice(0, -suffix.length) : iconName;
+};
 exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
     name: 'enforce-mui-rounded-icons',
     meta: {
@@ -36,8 +69,16 @@ exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
                     if (!iconName) {
                         return;
                     }
+                    // Map a non-Rounded variant import to its base icon so the Rounded
+                    // suggestion/fix targets a name that actually exists.
+                    const baseIconName = toBaseIconName(iconName);
+                    // Brand icons have no Rounded variant — demanding one is a false
+                    // positive and the fix would point at a non-existent module.
+                    if (ICONS_WITHOUT_ROUNDED.has(baseIconName)) {
+                        return;
+                    }
                     // Create the rounded variant name
-                    const roundedVariant = `${iconName}Rounded`;
+                    const roundedVariant = `${baseIconName}Rounded`;
                     context.report({
                         node,
                         messageId: 'enforceRoundedVariant',

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

@@ -20,6 +20,7 @@ const ALLOWLIST = {
     domain: new Set([
         'ai',
         'blumint',
+        'main',
         'middleware',
         'noop',
         'nth',
@@ -406,6 +407,8 @@ const ALLOWLIST = {
         'brush',
         'bubble',
         'buck',
+        'bucket',
+        'bucketize',
         'buckle',
         'bud',
         'budge',

package/lib/rules/global-const-style.js

@@ -158,6 +158,15 @@ exports.default = (0, createRule_1.createRule)({
                             if (target.type === utils_1.AST_NODE_TYPES.Literal && 'regex' in target) {
                                 return false;
                             }
+                            // Skip null and boolean literals. `null as const` is invalid
+                            // TypeScript (TS1355), so the autofix would produce uncompilable
+                            // code; `true`/`false` already have literal types, so `as const`
+                            // is redundant. (`undefined` is an Identifier, not a Literal, so
+                            // it never reaches the literal branch below.)
+                            if (target.type === utils_1.AST_NODE_TYPES.Literal &&
+                                (target.value === null || typeof target.value === 'boolean')) {
+                                return false;
+                            }
                             return (target.type === utils_1.AST_NODE_TYPES.Literal ||
                                 target.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
                                 target.type === utils_1.AST_NODE_TYPES.ObjectExpression);