@blumintinc/eslint-plugin-blumint 1.11.1 → 1.12.1

package/lib/index.js

@@ -106,7 +106,7 @@ const enforce_boolean_naming_prefixes_1 = require("./rules/enforce-boolean-namin
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.11.1',
+        version: '1.12.1',
     },
     parseOptions: {
         ecmaVersion: 2020,

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

@@ -121,9 +121,45 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 }
                 // Check for logical expressions (&&, ||)
                 if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
-                    ['&&', '||'].includes(node.init.operator)) {
+                    node.init.operator === '&&') {
                     return true;
                 }
+                // Special case for logical OR (||) - only consider it boolean if:
+                // 1. It's used with boolean literals or
+                // 2. It's not used with array/object literals as fallbacks
+                if (node.init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    node.init.operator === '||') {
+                    // Check if right side is a non-boolean literal (array, object, string, number)
+                    const rightSide = node.init.right;
+                    if (rightSide.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                        rightSide.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                        (rightSide.type === utils_1.AST_NODE_TYPES.Literal &&
+                            typeof rightSide.value !== 'boolean')) {
+                        return false;
+                    }
+                    // If right side is a boolean literal, it's likely a boolean variable
+                    if (rightSide.type === utils_1.AST_NODE_TYPES.Literal &&
+                        typeof rightSide.value === 'boolean') {
+                        return true;
+                    }
+                    // For other cases, we need to be more careful
+                    // If we can determine the left side is a boolean, then it's a boolean variable
+                    const leftSide = node.init.left;
+                    if ((leftSide.type === utils_1.AST_NODE_TYPES.Literal &&
+                        typeof leftSide.value === 'boolean') ||
+                        (leftSide.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                            leftSide.operator === '!')) {
+                        return true;
+                    }
+                    // For function calls, check if the function name suggests it returns a boolean
+                    if (leftSide.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                        leftSide.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const calleeName = leftSide.callee.name;
+                        return approvedPrefixes.some((prefix) => calleeName.toLowerCase().startsWith(prefix.toLowerCase()));
+                    }
+                    // Default to false for other cases with || to avoid false positives
+                    return false;
+                }
                 // Check for unary expressions with ! operator
                 if (node.init.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
                     node.init.operator === '!') {
@@ -349,6 +385,17 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 });
             }
         }
+        /**
+         * Check if an identifier is imported from an external module
+         */
+        function isImportedIdentifier(name) {
+            const scope = context.getScope();
+            const variable = scope.variables.find((v) => v.name === name);
+            if (!variable)
+                return false;
+            // Check if it's an import binding
+            return variable.defs.some((def) => def.type === 'ImportBinding');
+        }
         /**
          * Check property definitions for boolean values
          */
@@ -370,16 +417,51 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
                 isBooleanProperty = true;
             }
+            // Skip checking if this property is part of an object literal passed to an external function
             if (isBooleanProperty && !hasApprovedPrefix(propertyName)) {
-                context.report({
-                    node: node.key,
-                    messageId: 'missingBooleanPrefix',
-                    data: {
-                        type: 'property',
-                        name: propertyName,
-                        prefixes: formatPrefixes(),
-                    },
-                });
+                // Special cases for common Node.js API boolean properties
+                if ((propertyName === 'recursive' || propertyName === 'keepAlive') &&
+                    node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    node.parent.parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    return; // Skip checking for these properties in object literals passed to functions
+                }
+                // Check if this property is in an object literal that's an argument to a function call
+                let isExternalApiCall = false;
+                // Navigate up to find if we're in an object expression that's an argument to a function call
+                if (node.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    node.parent.parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const callExpression = node.parent.parent;
+                    // Check if the function being called is an identifier (like mkdirSync, createServer, etc.)
+                    if (callExpression.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const calleeName = callExpression.callee.name;
+                        if (isImportedIdentifier(calleeName)) {
+                            isExternalApiCall = true;
+                        }
+                    }
+                    // Also check for member expressions like fs.mkdirSync
+                    if (callExpression.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        // For member expressions, check if the object is imported
+                        const objectNode = callExpression.callee.object;
+                        if (objectNode.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const objectName = objectNode.name;
+                            if (isImportedIdentifier(objectName)) {
+                                isExternalApiCall = true;
+                            }
+                        }
+                    }
+                }
+                // Only report if it's not an external API call
+                if (!isExternalApiCall) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'missingBooleanPrefix',
+                        data: {
+                            type: 'property',
+                            name: propertyName,
+                            prefixes: formatPrefixes(),
+                        },
+                    });
+                }
             }
         }
         /**
@@ -394,15 +476,35 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                 node.typeAnnotation.typeAnnotation.type ===
                     utils_1.AST_NODE_TYPES.TSBooleanKeyword &&
                 !hasApprovedPrefix(propertyName)) {
-                context.report({
-                    node: node.key,
-                    messageId: 'missingBooleanPrefix',
-                    data: {
-                        type: 'property',
-                        name: propertyName,
-                        prefixes: formatPrefixes(),
-                    },
-                });
+                // Skip if this property is part of a parameter's type annotation
+                // Check if this property signature is inside a parameter's type annotation
+                let isInParameterType = false;
+                let parent = node.parent;
+                while (parent) {
+                    if (parent.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                        const grandParent = parent.parent;
+                        if (grandParent?.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+                            grandParent.parent?.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            grandParent.parent.parent?.type ===
+                                utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                            isInParameterType = true;
+                            break;
+                        }
+                    }
+                    parent = parent.parent;
+                }
+                // Only report if not in a parameter type annotation
+                if (!isInParameterType) {
+                    context.report({
+                        node: node.key,
+                        messageId: 'missingBooleanPrefix',
+                        data: {
+                            type: 'property',
+                            name: propertyName,
+                            prefixes: formatPrefixes(),
+                        },
+                    });
+                }
             }
         }
         /**
@@ -427,6 +529,31 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     },
                 });
             }
+            // Check if the parameter has an object type with boolean properties
+            if (node.typeAnnotation?.typeAnnotation &&
+                node.typeAnnotation.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                const typeLiteral = node.typeAnnotation.typeAnnotation;
+                // Check each member of the type literal
+                for (const member of typeLiteral.members) {
+                    if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                        member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        member.typeAnnotation?.typeAnnotation.type ===
+                            utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
+                        const propertyName = member.key.name;
+                        if (!hasApprovedPrefix(propertyName)) {
+                            context.report({
+                                node: member.key,
+                                messageId: 'missingBooleanPrefix',
+                                data: {
+                                    type: 'property',
+                                    name: propertyName,
+                                    prefixes: formatPrefixes(),
+                                },
+                            });
+                        }
+                    }
+                }
+            }
         }
         return {
             VariableDeclarator: checkVariableDeclaration,

package/lib/rules/enforce-positive-naming.js

@@ -5,11 +5,853 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 // Common negative prefixes for boolean variables
 const BOOLEAN_NEGATIVE_PREFIXES = ['not', 'no', 'non', 'un', 'in', 'dis'];
+const IN_EXCEPTIONS = [
+    'in',
+    'inane',
+    'inaugural',
+    'inaugurated',
+    'inauguration',
+    'inbound',
+    'inbox',
+    'incandescent',
+    'incarcerated',
+    'incarceration',
+    'incarnation',
+    'incendiary',
+    'incense',
+    'incentive',
+    'incentives',
+    'inception',
+    'incest',
+    'inch',
+    'inches',
+    'incidence',
+    'incident',
+    'incidental',
+    'incidentally',
+    'incidents',
+    'incision',
+    'incite',
+    'inciting',
+    'inclination',
+    'incline',
+    'inclined',
+    'include',
+    'included',
+    'includes',
+    'including',
+    'inclusion',
+    'inclusive',
+    'income',
+    'incomes',
+    'incoming',
+    'incorporate',
+    'incorporated',
+    'incorporates',
+    'incorporating',
+    'incorporation',
+    'increase',
+    'increased',
+    'increases',
+    'increasing',
+    'increasingly',
+    'incremental',
+    'increments',
+    'incriminating',
+    'incubation',
+    'incubator',
+    'incumbent',
+    'incumbents',
+    'incur',
+    'incurred',
+    'indebted',
+    'indeed',
+    'index',
+    'indexed',
+    'indexes',
+    'indexing',
+    'indicate',
+    'indicated',
+    'indicates',
+    'indicating',
+    'indication',
+    'indications',
+    'indicative',
+    'indicator',
+    'indicators',
+    'indices',
+    'indicted',
+    'indictment',
+    'indictments',
+    'indie',
+    'indies',
+    'indigenous',
+    'indignation',
+    'indigo',
+    'indoor',
+    'indoors',
+    'induce',
+    'induced',
+    'induces',
+    'inducing',
+    'inducted',
+    'induction',
+    'indulge',
+    'indulgence',
+    'indulgent',
+    'indulging',
+    'industrial',
+    'industrialized',
+    'industries',
+    'industry',
+    'inexpensive',
+    'infancy',
+    'infant',
+    'infantry',
+    'infants',
+    'infect',
+    'infected',
+    'infection',
+    'infections',
+    'infectious',
+    'infer',
+    'inference',
+    'inferior',
+    'inferno',
+    'inferred',
+    'infertility',
+    'infestation',
+    'infested',
+    'infidelity',
+    'infield',
+    'infiltrate',
+    'infiltrated',
+    'infiltration',
+    'infinite',
+    'infinitely',
+    'infinity',
+    'infirmary',
+    'inflamed',
+    'inflammation',
+    'inflammatory',
+    'inflatable',
+    'inflate',
+    'inflated',
+    'inflation',
+    'inflict',
+    'inflicted',
+    'inflicting',
+    'influence',
+    'influenced',
+    'influencers',
+    'influences',
+    'influencing',
+    'influential',
+    'influenza',
+    'influx',
+    'info',
+    'infographic',
+    'inform',
+    'informant',
+    'informants',
+    'informatics',
+    'information',
+    'informational',
+    'informative',
+    'informed',
+    'informing',
+    'informs',
+    'infrared',
+    'infrastructure',
+    'infringed',
+    'infringement',
+    'infringing',
+    'infuriating',
+    'infused',
+    'infusion',
+    'ingenious',
+    'ingenuity',
+    'ingested',
+    'ingot',
+    'ingrained',
+    'ingredient',
+    'ingredients',
+    'inhabit',
+    'inhabitants',
+    'inhabited',
+    'inhalation',
+    'inhale',
+    'inhaled',
+    'inhaling',
+    'inherent',
+    'inherently',
+    'inheritance',
+    'inherited',
+    'initial',
+    'initially',
+    'initials',
+    'initiate',
+    'initiated',
+    'initiates',
+    'initiating',
+    'initiation',
+    'initiative',
+    'initiatives',
+    'inject',
+    'injected',
+    'injecting',
+    'injection',
+    'injections',
+    'injunction',
+    'injure',
+    'injured',
+    'injuries',
+    'injuring',
+    'injury',
+    'ink',
+    'inked',
+    'inks',
+    'inland',
+    'inlay',
+    'inlet',
+    'inmate',
+    'inmates',
+    'inn',
+    'innate',
+    'inner',
+    'inning',
+    'innings',
+    'innovate',
+    'innovation',
+    'innovations',
+    'innovative',
+    'innovator',
+    'innovators',
+    'inns',
+    'inpatient',
+    'input',
+    'inputs',
+    'inquest',
+    'inquire',
+    'inquiries',
+    'inquiry',
+    'inquisition',
+    'ins',
+    'inscribed',
+    'inscription',
+    'inscriptions',
+    'insect',
+    'insects',
+    'insert',
+    'inserted',
+    'inserting',
+    'insertion',
+    'inserts',
+    'inside',
+    'insider',
+    'insiders',
+    'insides',
+    'insidious',
+    'insight',
+    'insightful',
+    'insights',
+    'insignia',
+    'insist',
+    'insisted',
+    'insistence',
+    'insistent',
+    'insisting',
+    'insists',
+    'insofar',
+    'inspect',
+    'inspected',
+    'inspecting',
+    'inspection',
+    'inspections',
+    'inspector',
+    'inspectors',
+    'inspiration',
+    'inspirational',
+    'inspirations',
+    'inspire',
+    'inspired',
+    'inspires',
+    'inspiring',
+    'install',
+    'installation',
+    'installations',
+    'installed',
+    'installing',
+    'installment',
+    'installments',
+    'instalment',
+    'instance',
+    'instances',
+    'instant',
+    'instantaneous',
+    'instantly',
+    'instead',
+    'instigated',
+    'instinct',
+    'instinctive',
+    'instinctively',
+    'instincts',
+    'institute',
+    'instituted',
+    'institutes',
+    'institution',
+    'institutional',
+    'institutions',
+    'instruct',
+    'instructed',
+    'instructing',
+    'instruction',
+    'instructional',
+    'instructions',
+    'instructor',
+    'instructors',
+    'instrument',
+    'instrumental',
+    'instrumentation',
+    'instruments',
+    'insular',
+    'insulated',
+    'insulating',
+    'insulation',
+    'insulin',
+    'insult',
+    'insulted',
+    'insulting',
+    'insults',
+    'insurance',
+    'insure',
+    'insured',
+    'insurer',
+    'insurers',
+    'insurgency',
+    'insurgent',
+    'insurgents',
+    'insurrection',
+    'intake',
+    'integers',
+    'intel',
+    'intellect',
+    'intellectual',
+    'intellectually',
+    'intellectuals',
+    'intelligence',
+    'intelligent',
+    'intelligently',
+    'intend',
+    'intended',
+    'intending',
+    'intends',
+    'intense',
+    'intensely',
+    'intensified',
+    'intensifies',
+    'intensify',
+    'intensity',
+    'intensive',
+    'intent',
+    'intention',
+    'intentional',
+    'intentionally',
+    'intentions',
+    'inter',
+    'interact',
+    'interacted',
+    'interacting',
+    'interaction',
+    'interactions',
+    'interactive',
+    'interacts',
+    'intercept',
+    'intercepted',
+    'interception',
+    'interceptions',
+    'interchange',
+    'interchangeable',
+    'interconnected',
+    'intercourse',
+    'interest',
+    'interested',
+    'interesting',
+    'interestingly',
+    'interests',
+    'interface',
+    'interfaces',
+    'interfere',
+    'interfered',
+    'interference',
+    'interferes',
+    'interfering',
+    'interim',
+    'interior',
+    'interiors',
+    'interlude',
+    'intermediary',
+    'intermediate',
+    'intermission',
+    'intermittent',
+    'intermittently',
+    'intern',
+    'internal',
+    'internally',
+    'international',
+    'internationally',
+    'internationals',
+    'interns',
+    'internship',
+    'internships',
+    'interpersonal',
+    'interplay',
+    'interpret',
+    'interpretation',
+    'interpretations',
+    'interpreted',
+    'interpreter',
+    'interpreters',
+    'interpreting',
+    'interpretive',
+    'interracial',
+    'interrogated',
+    'interrogation',
+    'interrupt',
+    'interrupted',
+    'interrupting',
+    'interruption',
+    'interruptions',
+    'interrupts',
+    'intersect',
+    'intersection',
+    'intersections',
+    'interspersed',
+    'interstate',
+    'interstellar',
+    'intertwined',
+    'interval',
+    'intervals',
+    'intervene',
+    'intervened',
+    'intervening',
+    'intervention',
+    'interventions',
+    'interview',
+    'interviewed',
+    'interviewer',
+    'interviewing',
+    'interviews',
+    'intestinal',
+    'intestine',
+    'intestines',
+    'intimacy',
+    'intimate',
+    'intimately',
+    'intimidate',
+    'intimidated',
+    'intimidating',
+    'intimidation',
+    'into',
+    'intoxicated',
+    'intoxication',
+    'intracellular',
+    'intravenous',
+    'intricate',
+    'intrigue',
+    'intrigued',
+    'intriguing',
+    'intrinsic',
+    'intrinsically',
+    'intro',
+    'introduce',
+    'introduced',
+    'introduces',
+    'introducing',
+    'introduction',
+    'introductions',
+    'introductory',
+    'intruder',
+    'intruders',
+    'intrusion',
+    'intrusive',
+    'intuition',
+    'intuitive',
+    'intuitively',
+    'inundated',
+    'invade',
+    'invaded',
+    'invaders',
+    'invading',
+    'invasion',
+    'invasions',
+    'invasive',
+    'invent',
+    'invented',
+    'inventing',
+    'invention',
+    'inventions',
+    'inventive',
+    'inventor',
+    'inventories',
+    'inventors',
+    'inventory',
+    'inverness',
+    'inverse',
+    'inversion',
+    'inverted',
+    'invest',
+    'invested',
+    'investigate',
+    'investigated',
+    'investigates',
+    'investigating',
+    'investigation',
+    'investigations',
+    'investigative',
+    'investigator',
+    'investigators',
+    'investing',
+    'investment',
+    'investments',
+    'investor',
+    'investors',
+    'invests',
+    'invitation',
+    'invitational',
+    'invitations',
+    'invite',
+    'invited',
+    'invites',
+    'inviting',
+    'invoice',
+    'invoices',
+    'invoke',
+    'invoked',
+    'invoking',
+    'involve',
+    'involved',
+    'involvement',
+    'involves',
+    'involving',
+    'inward',
+    'init',
+    'initial',
+    'initialization',
+    'initialize',
+    'initialized',
+    'initializing',
+    'initializes',
+    'initializing',
+    'initializes',
+];
+const NO_EXCEPTIONS = [
+    'nobility',
+    'noble',
+    'nobleman',
+    'nobles',
+    'nobly',
+    'nocturnal',
+    'nod',
+    'nodded',
+    'nodding',
+    'node',
+    'nodes',
+    'nods',
+    'noel',
+    'noir',
+    'noise',
+    'noises',
+    'noisy',
+    'nomad',
+    'nomadic',
+    'nomenclature',
+    'nominal',
+    'nominally',
+    'nominate',
+    'nominated',
+    'nominating',
+    'nomination',
+    'nominations',
+    'nominee',
+    'nominees',
+    'noodle',
+    'noodles',
+    'nook',
+    'noon',
+    'noose',
+    'norM',
+    'norma',
+    'normal',
+    'normalized',
+    'normally',
+    'normative',
+    'norms',
+    'north',
+    'northbound',
+    'northeast',
+    'northeastern',
+    'northern',
+    'northward',
+    'northwest',
+    'northwestern',
+    'nose',
+    'nosey',
+    'nostalgia',
+    'nostalgic',
+    'nostrils',
+    'notable',
+    'notably',
+    'notary',
+    'notation',
+    'notch',
+    'notched',
+    'notebook',
+    'notebooks',
+    'noted',
+    'notes',
+    'noteworthy',
+    'notice',
+    'noticeable',
+    'noticeably',
+    'noticed',
+    'notices',
+    'noticing',
+    'notification',
+    'notifications',
+    'notified',
+    'notify',
+    'notifying',
+    'notion',
+    'notions',
+    'notoriety',
+    'notorious',
+    'notoriously',
+    'noun',
+    'nouns',
+    'nourishment',
+    'nouveau',
+    'nova',
+    'novel',
+    'novelist',
+    'novelists',
+    'novella',
+    'novels',
+    'novelty',
+    'novice',
+    'now',
+    'nowadays',
+    'nozzle',
+];
+const UN_EXCEPTIONS = [
+    'unanimous',
+    'unanimously',
+    'uncle',
+    'uncles',
+    'under',
+    'underage',
+    'undercover',
+    'undercut',
+    'underdog',
+    'underestimate',
+    'underestimated',
+    'undergo',
+    'undergoes',
+    'undergoing',
+    'undergone',
+    'undergraduate',
+    'undergraduates',
+    'underground',
+    'underlined',
+    'underlying',
+    'undermine',
+    'undermined',
+    'undermines',
+    'undermining',
+    'underneath',
+    'underrated',
+    'underside',
+    'understand',
+    'understandable',
+    'understandably',
+    'understanding',
+    'understands',
+    'understated',
+    'understatement',
+    'understood',
+    'undertake',
+    'undertaken',
+    'undertaker',
+    'undertaking',
+    'undertook',
+    'underwater',
+    'underway',
+    'underwear',
+    'underwent',
+    'underwood',
+    'underworld',
+    'underwriting',
+    'unicorn',
+    'unicorns',
+    'unification',
+    'unified',
+    'uniform',
+    'uniformed',
+    'uniformity',
+    'uniformly',
+    'uniforms',
+    'unify',
+    'unifying',
+    'unilateral',
+    'unilaterally',
+    'union',
+    'unionist',
+    'unionists',
+    'unions',
+    'unique',
+    'uniquely',
+    'uniqueness',
+    'unison',
+    'unit',
+    'unitary',
+    'unite',
+    'united',
+    'unites',
+    'uniting',
+    'units',
+    'unity',
+    'universal',
+    'universally',
+    'universe',
+    'universes',
+    'universities',
+    'university',
+    'unless',
+    'until',
+    'unto',
+];
+const DIS_EXCEPTIONS = [
+    'disc',
+    'disciple',
+    'disciples',
+    'disciplinary',
+    'discipline',
+    'disciplined',
+    'disciplines',
+    'disco',
+    'discography',
+    'discern',
+    'discerning',
+    'discourse',
+    'discreet',
+    'discreetly',
+    'discrepancies',
+    'discrepancy',
+    'discrete',
+    'discretion',
+    'discretionary',
+    'discriminate',
+    'discriminated',
+    'discriminating',
+    'discrimination',
+    'discriminatory',
+    'discs',
+    'discuss',
+    'discussed',
+    'discusses',
+    'discussing',
+    'discussion',
+    'discussions',
+    'disengage',
+    'disparate',
+    'dispensary',
+    'dispense',
+    'dispenser',
+    'dispensing',
+    'disperse',
+    'dispersed',
+    'dispersion',
+    'disposition',
+    'disseminate',
+    'dissemination',
+    'dissertation',
+    'dissident',
+    'dissidents',
+    'dissimilar',
+    'dissipated',
+    'dissolution',
+    'dissolve',
+    'dissolved',
+    'dissolving',
+    'distal',
+    'distance',
+    'distances',
+    'distancing',
+    'distant',
+    'distillation',
+    'distilled',
+    'distillery',
+    'distinct',
+    'distinction',
+    'distinctions',
+    'distinctive',
+    'distinctly',
+    'distinguish',
+    'distinguished',
+    'distinguishes',
+    'distinguishing',
+    'distort',
+    'distorted',
+    'distortion',
+    'distortions',
+    'distract',
+    'distracted',
+    'distracting',
+    'distraction',
+    'distractions',
+    'distraught',
+    'distribute',
+    'distributed',
+    'distributes',
+    'distributing',
+    'distribution',
+    'distributions',
+    'distributor',
+    'distributors',
+    'district',
+    'districts',
+    'dismal',
+    'disaster',
+    'disasters',
+    'disastrous',
+];
 // Words that contain negative prefixes but should be treated as valid
-const EXCEPTION_WORDS = ['interaction', 'interactions'];
+const EXCEPTION_WORDS = [
+    ...IN_EXCEPTIONS,
+    ...NO_EXCEPTIONS,
+    ...UN_EXCEPTIONS,
+    ...DIS_EXCEPTIONS,
+];
+/**
+ * Splits a variable name into individual words based on naming conventions:
+ * - camelCase or PascalCase: split on uppercase letters
+ * - SCREAMING_SNAKE_CASE: split on underscores
+ * @param name Variable name to split
+ * @returns Array of individual words in lowercase
+ */
+function splitNameIntoWords(name) {
+    // Handle SCREAMING_SNAKE_CASE
+    if (name.includes('_')) {
+        return name.toLowerCase().split('_').filter(Boolean);
+    }
+    // Handle camelCase and PascalCase
+    // Add space before uppercase letters and then split
+    const spacedName = name.replace(/([A-Z])/g, ' $1');
+    return spacedName.toLowerCase().trim().split(/\s+/).filter(Boolean);
+}
 // Map of negative boolean terms to suggested positive alternatives
 const BOOLEAN_POSITIVE_ALTERNATIVES = {
-    // Boolean prefixes
+    // Boolean prefixes - These will be removed from suggestions
     isNot: ['is'],
     isUn: ['is'],
     isDis: ['is'],
@@ -21,6 +863,28 @@ const BOOLEAN_POSITIVE_ALTERNATIVES = {
     shouldNot: ['should'],
     willNot: ['will'],
     doesNot: ['does'],
+    IsNot: ['Is'],
+    IsUn: ['Is'],
+    IsDis: ['Is'],
+    IsIn: ['Is'],
+    IsNon: ['Is'],
+    HasNo: ['Has'],
+    HasNot: ['Has'],
+    CanNot: ['Can'],
+    ShouldNot: ['Should'],
+    WillNot: ['Will'],
+    DoesNot: ['Does'],
+    IS_NOT: ['IS'],
+    IS_UN: ['IS'],
+    IS_DIS: ['IS'],
+    IS_IN: ['IS'],
+    IS_NON: ['IS'],
+    HAS_NO: ['HAS'],
+    HAS_NOT: ['HAS'],
+    CAN_NOT: ['CAN'],
+    SHOULD_NOT: ['SHOULD'],
+    WILL_NOT: ['WILL'],
+    DOES_NOT: ['DOES'],
 };
 exports.enforcePositiveNaming = (0, createRule_1.createRule)({
     name: 'enforce-positive-naming',
@@ -63,46 +927,98 @@ exports.enforcePositiveNaming = (0, createRule_1.createRule)({
                     alternatives: BOOLEAN_POSITIVE_ALTERNATIVES[name],
                 };
             }
+            // Split the name into words
+            const words = splitNameIntoWords(name);
+            // Check if this follows the pattern IS_NOT_SOMETHING or HAS_NO_SOMETHING
+            const secondWord = words[1].toLowerCase();
+            if (EXCEPTION_WORDS.some((exception) => secondWord === exception.toLowerCase())) {
+                return { isNegative: false, alternatives: [] };
+            }
+            const nameLowercase = name.toLowerCase();
             // Check for negative prefixes in boolean-like variables
-            if (name.startsWith('is') ||
-                name.startsWith('has') ||
-                name.startsWith('can') ||
-                name.startsWith('should') ||
-                name.startsWith('will') ||
-                name.startsWith('does')) {
-                // Check if the name contains any exception words
-                for (const exceptionWord of EXCEPTION_WORDS) {
-                    const lowerCaseName = name.toLowerCase();
-                    if (lowerCaseName.includes(exceptionWord.toLowerCase())) {
-                        return { isNegative: false, alternatives: [] };
-                    }
-                }
+            if (nameLowercase.startsWith('is') ||
+                nameLowercase.startsWith('has') ||
+                nameLowercase.startsWith('can') ||
+                nameLowercase.startsWith('should') ||
+                nameLowercase.startsWith('will') ||
+                nameLowercase.startsWith('does')) {
+                // We already checked exception words above, so no need to check again
                 for (const prefix of BOOLEAN_NEGATIVE_PREFIXES) {
+                    const prefixCapitalized = prefix.charAt(0).toUpperCase() + prefix.slice(1);
+                    const prefixUppercase = prefix.toUpperCase();
                     // Check for patterns like isNot, hasNo, canNot, etc.
                     const prefixPatterns = [
                         {
-                            pattern: new RegExp(`^is${prefix}`, 'i'),
-                            key: `is${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                            pattern: new RegExp(`^is${prefixCapitalized}`, 'i'),
+                            key: `is${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^has${prefixCapitalized}`, 'i'),
+                            key: `has${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^can${prefixCapitalized}`, 'i'),
+                            key: `can${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^should${prefixCapitalized}`, 'i'),
+                            key: `should${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^will${prefixCapitalized}`, 'i'),
+                            key: `will${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^does${prefixCapitalized}`, 'i'),
+                            key: `does${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^Is${prefixCapitalized}`, 'i'),
+                            key: `Is${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^Has${prefixCapitalized}`, 'i'),
+                            key: `Has${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^Can${prefixCapitalized}`, 'i'),
+                            key: `Can${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^Should${prefixCapitalized}`, 'i'),
+                            key: `Should${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^Will${prefixCapitalized}`, 'i'),
+                            key: `Will${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^Does${prefixCapitalized}`, 'i'),
+                            key: `Does${prefixCapitalized}`,
+                        },
+                        {
+                            pattern: new RegExp(`^IS_${prefixUppercase}`, 'i'),
+                            key: `IS_${prefixUppercase}`,
                         },
                         {
-                            pattern: new RegExp(`^has${prefix}`, 'i'),
-                            key: `has${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                            pattern: new RegExp(`^HAS_${prefixUppercase}`, 'i'),
+                            key: `HAS_${prefixUppercase}`,
                         },
                         {
-                            pattern: new RegExp(`^can${prefix}`, 'i'),
-                            key: `can${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                            pattern: new RegExp(`^CAN_${prefixUppercase}`, 'i'),
+                            key: `CAN_${prefixUppercase}`,
                         },
                         {
-                            pattern: new RegExp(`^should${prefix}`, 'i'),
-                            key: `should${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                            pattern: new RegExp(`^SHOULD_${prefixUppercase}`, 'i'),
+                            key: `SHOULD_${prefixUppercase}`,
                         },
                         {
-                            pattern: new RegExp(`^will${prefix}`, 'i'),
-                            key: `will${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                            pattern: new RegExp(`^WILL_${prefixUppercase}`, 'i'),
+                            key: `WILL_${prefixUppercase}`,
                         },
                         {
-                            pattern: new RegExp(`^does${prefix}`, 'i'),
-                            key: `does${prefix.charAt(0).toUpperCase() + prefix.slice(1)}`,
+                            pattern: new RegExp(`^DOES_${prefixUppercase}`, 'i'),
+                            key: `DOES_${prefixUppercase}`,
                         },
                     ];
                     for (const { pattern, key } of prefixPatterns) {

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

@@ -37,7 +37,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. Consider alternatives or explicitly document intentional layer promotion.',
+            description: 'Warn when using CSS properties that trigger compositing layers, which can impact performance. Properties like transform, opacity, filter, and will-change create new GPU layers. While sometimes beneficial for animations, excessive layer creation can increase memory usage and hurt performance. This rule checks both regular style objects and MUI sx props. Consider alternatives or explicitly document intentional layer promotion.',
             recommended: 'error',
         },
         schema: [],
@@ -79,7 +79,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                 // Check for JSX style attribute
                 if (current.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
                     current.parent.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
-                    current.parent.name.name === 'style') {
+                    (current.parent.name.name === 'style' || current.parent.name.name === 'sx')) {
                     return true;
                 }
                 // Check for style-related variable names or properties
@@ -91,7 +91,7 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                 // Check for style-related object property assignments
                 if (current.parent.type === utils_1.AST_NODE_TYPES.Property &&
                     current.parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    /style/i.test(current.parent.key.name)) {
+                    (/style/i.test(current.parent.key.name) || current.parent.key.name === 'sx')) {
                     return true;
                 }
                 // Skip if we're in a TypeScript type definition
@@ -142,9 +142,9 @@ exports.noCompositingLayerProps = (0, createRule_1.createRule)({
                     return;
                 checkNode(node);
             },
-            // Handle JSX style attributes
+            // Handle JSX style and sx attributes
             JSXAttribute(node) {
-                if (node.name.name !== 'style')
+                if (node.name.name !== 'style' && node.name.name !== 'sx')
                     return;
                 if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
                     node.value.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {

package/package.json

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