@blumintinc/eslint-plugin-blumint 1.11.0 → 1.12.0

package/lib/index.js

@@ -15,6 +15,7 @@ const enforce_mui_rounded_icons_1 = require("./rules/enforce-mui-rounded-icons")
 const enforce_react_type_naming_1 = require("./rules/enforce-react-type-naming");
 const export_if_in_doubt_1 = require("./rules/export-if-in-doubt");
 const extract_global_constants_1 = require("./rules/extract-global-constants");
+const enforce_global_constants_1 = require("./rules/enforce-global-constants");
 const generic_starts_with_t_1 = require("./rules/generic-starts-with-t");
 const global_const_style_1 = __importDefault(require("./rules/global-const-style"));
 const no_async_array_filter_1 = require("./rules/no-async-array-filter");
@@ -105,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.0',
+        version: '1.12.0',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -130,6 +131,7 @@ module.exports = {
                 '@blumintinc/blumint/enforce-react-type-naming': 'error',
                 // '@blumintinc/blumint/export-if-in-doubt': 'warn',
                 '@blumintinc/blumint/extract-global-constants': 'error',
+                '@blumintinc/blumint/enforce-global-constants': 'error',
                 '@blumintinc/blumint/generic-starts-with-t': 'error',
                 '@blumintinc/blumint/global-const-style': 'error',
                 '@blumintinc/blumint/no-async-array-filter': 'error',
@@ -236,6 +238,7 @@ module.exports = {
         'enforce-mui-rounded-icons': enforce_mui_rounded_icons_1.enforceMuiRoundedIcons,
         'export-if-in-doubt': export_if_in_doubt_1.exportIfInDoubt,
         'extract-global-constants': extract_global_constants_1.extractGlobalConstants,
+        'enforce-global-constants': enforce_global_constants_1.enforceGlobalConstants,
         'generic-starts-with-t': generic_starts_with_t_1.genericStartsWithT,
         'global-const-style': global_const_style_1.default,
         'no-async-array-filter': no_async_array_filter_1.noAsyncArrayFilter,

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

@@ -349,6 +349,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 +381,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 +440,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 +493,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-global-constants.d.ts

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

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceGlobalConstants = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceGlobalConstants = (0, createRule_1.createRule)({
+    name: 'enforce-global-constants',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using global static constants instead of useMemo with empty dependency arrays for object literals',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            useGlobalConstant: 'Use a global static constant instead of useMemo with an empty dependency array for object literals',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                // Check if it's a useMemo call
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    node.callee.name !== 'useMemo') {
+                    return;
+                }
+                // Check if it has exactly two arguments
+                if (node.arguments.length !== 2) {
+                    return;
+                }
+                // Check if the second argument is an empty array
+                const depsArray = node.arguments[1];
+                if (depsArray.type !== utils_1.AST_NODE_TYPES.ArrayExpression ||
+                    depsArray.elements.length !== 0) {
+                    return;
+                }
+                // Check if the first argument is an arrow function
+                const callback = node.arguments[0];
+                if (callback.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    return;
+                }
+                // Check if the arrow function body is a block statement with a return statement
+                // or a direct expression (implicit return)
+                let returnValue = null;
+                if (callback.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    // If it's a block, find the return statement
+                    const returnStatement = callback.body.body.find((stmt) => stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement);
+                    if (!returnStatement || !returnStatement.argument) {
+                        return;
+                    }
+                    returnValue = returnStatement.argument;
+                }
+                else {
+                    // If it's an expression (implicit return)
+                    returnValue = callback.body;
+                }
+                // Handle 'as const' type assertions
+                let actualReturnValue = returnValue;
+                if (returnValue.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                    actualReturnValue = returnValue.expression;
+                }
+                // Check if the return value is an object literal or an array of object literals
+                if (actualReturnValue.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
+                    (actualReturnValue.type === utils_1.AST_NODE_TYPES.ArrayExpression &&
+                        actualReturnValue.elements.some((element) => element !== null &&
+                            element.type === utils_1.AST_NODE_TYPES.ObjectExpression))) {
+                    context.report({
+                        node,
+                        messageId: 'useGlobalConstant',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-global-constants.js.map

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-hungarian.js

@@ -31,7 +31,7 @@ const TYPE_MARKERS = [
     ...COMMON_TYPES,
     'Class',
     'Interface',
-    'Type',
+    //'Type', people like to use 'type' as a general purpose noun
     'Enum',
 ];
 // Allowed descriptive suffixes that should not be flagged as Hungarian notation

package/lib/rules/no-type-assertion-returns.js

@@ -168,9 +168,21 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                 return true;
             }
             // Allow type assertions as arguments to constructors
-            if (node.parent?.type === utils_1.AST_NODE_TYPES.NewExpression) {
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.NewExpression ||
+                (node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.parent.parent?.type === utils_1.AST_NODE_TYPES.NewExpression)) {
                 return true;
             }
+            // Allow type assertions as arguments to constructor calls
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                let current = node.parent;
+                while (current?.parent) {
+                    if (current.parent.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                        return true;
+                    }
+                    current = current.parent;
+                }
+            }
             // Allow type assertions in JSX attributes/props or object properties
             if (isInsideJSXAttributeOrObjectProperty(node)) {
                 return true;

package/package.json

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