@blumintinc/eslint-plugin-blumint 1.8.2 → 1.9.1

package/lib/index.js

@@ -96,10 +96,11 @@ const enforce_css_media_queries_1 = require("./rules/enforce-css-media-queries")
 const omit_index_html_1 = require("./rules/omit-index-html");
 const enforce_id_capitalization_1 = require("./rules/enforce-id-capitalization");
 const no_unused_usestate_1 = require("./rules/no-unused-usestate");
+const no_uuidv4_base62_as_key_1 = require("./rules/no-uuidv4-base62-as-key");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.8.2',
+        version: '1.9.1',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -134,6 +135,7 @@ module.exports = {
                 '@blumintinc/blumint/no-misused-switch-case': 'error',
                 '@blumintinc/blumint/no-unpinned-dependencies': 'error',
                 '@blumintinc/blumint/no-unused-props': 'error',
+                '@blumintinc/blumint/no-uuidv4-base62-as-key': 'error',
                 //'@blumintinc/blumint/no-useless-fragment': 'error',
                 //'@blumintinc/blumint/prefer-fragment-shorthand': 'error',
                 '@blumintinc/blumint/prefer-type-over-interface': 'error',
@@ -235,6 +237,7 @@ module.exports = {
         'no-unpinned-dependencies': no_unpinned_dependencies_1.noUnpinnedDependencies,
         'no-unused-props': no_unused_props_1.noUnusedProps,
         'no-useless-fragment': no_useless_fragment_1.noUselessFragment,
+        'no-uuidv4-base62-as-key': no_uuidv4_base62_as_key_1.noUuidv4Base62AsKey,
         'prefer-fragment-shorthand': prefer_fragment_shorthand_1.preferFragmentShorthand,
         'prefer-type-over-interface': prefer_type_over_interface_1.preferTypeOverInterface,
         'require-memo': require_memo_1.requireMemo,

package/lib/rules/no-hungarian.d.ts

@@ -1,5 +1 @@
-type Options = {
-    allowClassInstances?: boolean;
-};
-export declare const noHungarian: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noHungarian", [Options], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
-export {};
+export declare const noHungarian: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noHungarian", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-hungarian.js

@@ -2,220 +2,376 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noHungarian = void 0;
 const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
 // Common built-in types that might be used in Hungarian notation
 const COMMON_TYPES = [
-    'String', 'Number', 'Boolean', 'Array', 'Object',
-    'Function', 'Date', 'RegExp', 'Promise', 'Map',
-    'Set', 'Symbol', 'BigInt', 'Error'
+    'String',
+    'Number',
+    'Boolean',
+    'Array',
+    'Object',
+    'Function',
+    'Date',
+    'RegExp',
+    'Promise',
+    'Symbol',
+    'BigInt',
 ];
-// Common Hungarian notation prefixes
-const HUNGARIAN_PREFIXES = [
-    'str', 'num', 'int', 'bool', 'arr', 'obj', 'fn', 'func'
+// Combined type markers (former Hungarian prefixes and type suffixes)
+const TYPE_MARKERS = [
+    'str',
+    'num',
+    'int',
+    'bool',
+    'arr',
+    'obj',
+    'fn',
+    'func',
+    'array',
+    ...COMMON_TYPES,
+    'Class',
+    'Interface',
+    'Type',
+    'Enum',
 ];
+// Common built-in JavaScript prototype methods
+const BUILT_IN_METHODS = new Set([
+    // String methods
+    'charAt',
+    'charCodeAt',
+    'codePointAt',
+    'concat',
+    'endsWith',
+    'includes',
+    'indexOf',
+    'lastIndexOf',
+    'localeCompare',
+    'match',
+    'matchAll',
+    'normalize',
+    'padEnd',
+    'padStart',
+    'repeat',
+    'replace',
+    'replaceAll',
+    'search',
+    'slice',
+    'split',
+    'startsWith',
+    'substring',
+    'toLocaleLowerCase',
+    'toLocaleUpperCase',
+    'toLowerCase',
+    'toString',
+    'toUpperCase',
+    'trim',
+    'trimEnd',
+    'trimStart',
+    'valueOf',
+    // Array methods
+    'forEach',
+    'map',
+    'filter',
+    'reduce',
+    'reduceRight',
+    'some',
+    'every',
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'keys',
+    'values',
+    'entries',
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'slice',
+    'splice',
+    'sort',
+    'reverse',
+    'flatMap',
+    'flat',
+    'concat',
+    'join',
+    'includes',
+    'indexOf',
+    'lastIndexOf',
+    'fill',
+    'copyWithin',
+    // Object methods
+    'hasOwnProperty',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toLocaleString',
+    'toString',
+    'valueOf',
+    'assign',
+    'create',
+    'defineProperty',
+    'defineProperties',
+    'entries',
+    'freeze',
+    'fromEntries',
+    'getOwnPropertyDescriptor',
+    'getOwnPropertyDescriptors',
+    'getOwnPropertyNames',
+    'getOwnPropertySymbols',
+    'getPrototypeOf',
+    'is',
+    'isExtensible',
+    'isFrozen',
+    'isSealed',
+    'keys',
+    'preventExtensions',
+    'seal',
+    'setPrototypeOf',
+    'values',
+    // Date methods
+    'getDate',
+    'getDay',
+    'getFullYear',
+    'getHours',
+    'getMilliseconds',
+    'getMinutes',
+    'getMonth',
+    'getSeconds',
+    'getTime',
+    'getTimezoneOffset',
+    'getUTCDate',
+    'getUTCDay',
+    'getUTCFullYear',
+    'getUTCHours',
+    'getUTCMilliseconds',
+    'getUTCMinutes',
+    'getUTCMonth',
+    'getUTCSeconds',
+    'setDate',
+    'setFullYear',
+    'setHours',
+    'setMilliseconds',
+    'setMinutes',
+    'setMonth',
+    'setSeconds',
+    'setTime',
+    'setUTCDate',
+    'setUTCFullYear',
+    'setUTCHours',
+    'setUTCMilliseconds',
+    'setUTCMinutes',
+    'setUTCMonth',
+    'setUTCSeconds',
+    'toDateString',
+    'toISOString',
+    'toJSON',
+    'toLocaleDateString',
+    'toLocaleString',
+    'toLocaleTimeString',
+    'toString',
+    'toTimeString',
+    'toUTCString',
+    'valueOf',
+    // Promise methods
+    'then',
+    'catch',
+    'finally',
+]);
 exports.noHungarian = (0, createRule_1.createRule)({
     name: 'no-hungarian',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Disallow Hungarian notation in variable names',
+            description: 'Disallow Hungarian notation in locally declared variables, types, and classes',
             recommended: 'error',
         },
-        fixable: 'code',
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    allowClassInstances: {
-                        type: 'boolean',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
+        fixable: undefined,
+        schema: [],
         messages: {
             noHungarian: 'Avoid Hungarian notation in variable name "{{name}}"',
         },
     },
-    defaultOptions: [
-        {
-            allowClassInstances: true,
-        },
-    ],
-    create(context, [options]) {
-        const allowClassInstances = options.allowClassInstances !== false;
-        // Helper function to extract the class/type name from a node
-        function getTypeName(node) {
-            if (!node)
-                return null;
-            // Handle new expressions (e.g., new Controller())
-            if (node.type === 'NewExpression' && node.callee.type === 'Identifier') {
-                return node.callee.name;
+    defaultOptions: [],
+    create(context) {
+        // Track identifiers that have already been checked to prevent double reporting
+        const checkedIdentifiers = new Set();
+        // Check if a variable name contains a type marker with proper word boundaries
+        function hasTypeMarker(variableName) {
+            const normalizedVarName = variableName.toLowerCase();
+            // Handle SCREAMING_SNAKE_CASE separately
+            if (variableName === variableName.toUpperCase() &&
+                variableName.includes('_')) {
+                return TYPE_MARKERS.some((marker) => {
+                    const markerUpper = marker.toUpperCase();
+                    // Check if it's a prefix (PREFIX_REST)
+                    if (variableName.startsWith(markerUpper + '_') &&
+                        variableName.length > markerUpper.length + 1) {
+                        return true;
+                    }
+                    // Check if it's a suffix (REST_SUFFIX)
+                    if (variableName.endsWith('_' + markerUpper) &&
+                        variableName.length > markerUpper.length + 1) {
+                        return true;
+                    }
+                    // Check if it's in the middle (PART_MARKER_PART)
+                    const parts = variableName.split('_');
+                    return parts.some((part) => part === markerUpper);
+                });
             }
-            // Handle type annotations if available
-            if (node.type === 'TSTypeAnnotation') {
-                const typeNode = node.typeAnnotation;
-                if (typeNode.type === 'TSStringKeyword')
-                    return 'String';
-                if (typeNode.type === 'TSNumberKeyword')
-                    return 'Number';
-                if (typeNode.type === 'TSBooleanKeyword')
-                    return 'Boolean';
-                if (typeNode.type === 'TSArrayType')
-                    return 'Array';
-                if (typeNode.type === 'TSObjectKeyword')
-                    return 'Object';
-                if (typeNode.type === 'TSFunctionType')
-                    return 'Function';
-                // Handle reference types like interfaces or classes
-                if (typeNode.type === 'TSTypeReference' && typeNode.typeName.type === 'Identifier') {
-                    return typeNode.typeName.name;
+            // For camelCase, PascalCase, etc.
+            return TYPE_MARKERS.some((marker) => {
+                const normalizedMarker = marker.toLowerCase();
+                // If the variable name is exactly the marker, ignore it
+                if (normalizedVarName === normalizedMarker) {
+                    return false;
                 }
-            }
-            return null;
-        }
-        // Check if a variable name has a type name as suffix (Hungarian notation)
-        function hasTypeSuffix(variableName, typeName) {
-            // Normalize both strings to lowercase for case-insensitive comparison
-            const normalizedVarName = variableName.toLowerCase();
-            const normalizedTypeName = typeName.toLowerCase();
-            // Check if the variable name ends with the type name (suffix)
-            return normalizedVarName.endsWith(normalizedTypeName) &&
-                normalizedVarName !== normalizedTypeName;
-        }
-        // Check if a variable name has a Hungarian prefix
-        function hasHungarianPrefix(variableName) {
-            const normalizedVarName = variableName.toLowerCase();
-            return HUNGARIAN_PREFIXES.some(prefix => {
-                // Check if the variable starts with the prefix
-                return normalizedVarName.startsWith(prefix.toLowerCase()) &&
-                    // Make sure it's not just the prefix itself
-                    normalizedVarName.length > prefix.length;
+                // Check if it's a prefix with proper boundary (e.g., strName, numCount)
+                if (normalizedVarName.startsWith(normalizedMarker) &&
+                    normalizedVarName.length > normalizedMarker.length &&
+                    /[A-Z0-9]/.test(variableName[normalizedMarker.length])) {
+                    return true;
+                }
+                // Check if it's a suffix with proper boundary (e.g., userString, itemArray)
+                if (normalizedVarName.endsWith(normalizedMarker) &&
+                    normalizedVarName.length > normalizedMarker.length &&
+                    /[A-Z0-9]/.test(variableName[variableName.length - normalizedMarker.length - 1])) {
+                    return true;
+                }
+                const markerIndex = normalizedVarName.indexOf(normalizedMarker);
+                if (markerIndex === -1) {
+                    return false;
+                }
+                const markerPrefix = variableName.at(markerIndex);
+                const preMarkerPrefix = variableName.at(markerIndex - 1);
+                const suffix = variableName.at(markerIndex + normalizedMarker.length);
+                return ((!markerPrefix ||
+                    preMarkerPrefix === '_' ||
+                    /[A-Z]/.test(markerPrefix)) &&
+                    (!suffix || suffix === '_' || /[A-Z]/.test(suffix)));
             });
         }
-        // Check if a variable name uses Hungarian notation
-        function isHungarianNotation(variableName, declaredTypeName) {
-            // Check for Hungarian prefixes (e.g., strName, boolIsActive)
-            if (hasHungarianPrefix(variableName)) {
-                return true;
-            }
-            // Check for type suffixes (e.g., nameString, countNumber)
-            // If we have a declared type, check if it's used as a suffix
-            if (declaredTypeName && hasTypeSuffix(variableName, declaredTypeName)) {
-                return true;
+        // Check if the identifier is a built-in method or imported from an external module
+        function isExternalOrBuiltIn(node) {
+            // Check if the identifier is a property in a member expression
+            // (e.g., the 'startsWith' in 'pathname.startsWith')
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.parent.property === node) {
+                // Check if it's a known built-in method
+                if (BUILT_IN_METHODS.has(node.name)) {
+                    return true;
+                }
             }
-            // Check against common types if no declared type is found
-            return COMMON_TYPES.some(typeName => hasTypeSuffix(variableName, typeName));
-        }
-        // Helper function to check if a variable name contains a class name
-        function variableContainsClassName(varName, className) {
-            return varName.toLowerCase().includes(className.toLowerCase());
-        }
-        // Helper function to check if a node is a class property or method
-        function isClassProperty(node) {
-            let current = node.parent;
-            while (current) {
-                if (current.type === 'ClassBody' || current.type === 'ClassDeclaration' || current.type === 'ClassExpression') {
+            // Check if it's an imported identifier
+            const scope = context.getScope();
+            const variable = scope.variables.find((v) => v.name === node.name);
+            if (variable && variable.defs.length > 0) {
+                // Check if it's an import binding
+                const def = variable.defs[0];
+                if (def.type === 'ImportBinding') {
                     return true;
                 }
-                current = current.parent;
             }
             return false;
         }
-        // Helper function to check if a variable name is a valid exception
-        function isValidException(variableName) {
-            // List of valid variable names that might be incorrectly flagged
-            const validExceptions = [
-                'stringifyData', 'numberFormatter', 'booleanLogic', 'arrayMethods',
-                'objectAssign', 'booleanToggle', 'arrayHelpers', 'objectMapper',
-                'stringBuilder', 'numberParser', 'booleanEvaluator', 'arrayCollection',
-                'objectPool', 'myStringUtils', 'numberConverter', 'strongPassword',
-                'wrongAnswer', 'longList', 'foreignKey'
-            ];
-            return validExceptions.includes(variableName);
-        }
-        // Helper function to check if a variable name is in the test cases
-        function isTestCase(variableName) {
-            // List of variable names from the test cases that should be flagged
-            const testCases = [
-                'usernameString', 'isReadyBoolean', 'countNumber', 'itemsArray',
-                'userDataObject', 'resultString', 'indexNumber', 'nameString',
-                'ageNumber', 'outerString', 'innerString', 'nestedString',
-                'userObjectArray', 'arrayOfItems', 'strName', 'intAge', 'boolIsActive'
-            ];
-            return testCases.includes(variableName);
+        // Check identifier for type markers (Hungarian notation)
+        function checkIdentifier(node) {
+            const name = node.name;
+            // Create a unique ID for this node to avoid checking it twice
+            // Use the name along with source location for uniqueness
+            const nodeId = `${name}:${node.loc.start.line}:${node.loc.start.column}`;
+            // Skip if we've already checked this identifier
+            if (checkedIdentifiers.has(nodeId)) {
+                return;
+            }
+            // Mark this identifier as checked
+            checkedIdentifiers.add(nodeId);
+            // Skip if the identifier is a built-in method or imported from an external module
+            if (isExternalOrBuiltIn(node))
+                return;
+            // Check for type markers
+            if (hasTypeMarker(name)) {
+                context.report({
+                    node,
+                    messageId: 'noHungarian',
+                    data: { name },
+                });
+            }
         }
         return {
+            // Check variable declarations
             VariableDeclarator(node) {
-                // Skip destructuring patterns
-                if (node.id.type !== 'Identifier') {
-                    return;
-                }
-                const variableName = node.id.name;
-                // Skip variables that are exactly the same as a type name
-                if (COMMON_TYPES.includes(variableName)) {
-                    return;
+                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    checkIdentifier(node.id);
                 }
-                // Skip known valid exceptions
-                if (isValidException(variableName)) {
-                    return;
+            },
+            // Check function declarations
+            FunctionDeclaration(node) {
+                if (node.id) {
+                    checkIdentifier(node.id);
                 }
-                // Special handling for test cases
-                if (isTestCase(variableName)) {
-                    context.report({
-                        node,
-                        messageId: 'noHungarian',
-                        data: {
-                            name: variableName,
-                        },
-                    });
-                    return;
+                // Check function parameters
+                for (const param of node.params) {
+                    if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        checkIdentifier(param);
+                    }
+                    else if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                        param.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        checkIdentifier(param.left);
+                    }
                 }
-                // Get type information from initialization or type annotation
-                let typeName = null;
-                // Check for type annotation
-                if (node.id.typeAnnotation) {
-                    typeName = getTypeName(node.id.typeAnnotation);
+            },
+            // Check function expressions and arrow functions
+            'FunctionExpression, ArrowFunctionExpression'(node) {
+                // Check function parameters
+                for (const param of node.params) {
+                    if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        checkIdentifier(param);
+                    }
+                    else if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                        param.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        checkIdentifier(param.left);
+                    }
                 }
-                // Check initialization if no type annotation or to get more specific type
-                if (!typeName && node.init) {
-                    typeName = getTypeName(node.init);
+            },
+            // Check class declarations
+            ClassDeclaration(node) {
+                if (node.id) {
+                    checkIdentifier(node.id);
                 }
-                // Handle class instances
-                if (node.init && node.init.type === 'NewExpression') {
-                    const className = getTypeName(node.init);
-                    // If we're allowing class instances and the variable name contains the class name
-                    if (allowClassInstances && className && variableContainsClassName(variableName, className)) {
-                        return;
+                // Check class methods and properties
+                for (const member of node.body.body) {
+                    if (member.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                        member.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // Check method name
+                        checkIdentifier(member.key);
+                        // Check method parameters
+                        if (member.value.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                            for (const param of member.value.params) {
+                                if (param.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    checkIdentifier(param);
+                                }
+                                else if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                                    param.left.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    checkIdentifier(param.left);
+                                }
+                            }
+                        }
                     }
-                    // Special handling for the case with allowClassInstances: false
-                    if (!allowClassInstances && className && variableContainsClassName(variableName, className)) {
-                        context.report({
-                            node,
-                            messageId: 'noHungarian',
-                            data: {
-                                name: variableName,
-                            },
-                        });
-                        return;
+                    else if (member.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+                        member.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // Check property name
+                        checkIdentifier(member.key);
                     }
                 }
-                // Check if the variable name uses Hungarian notation
-                if (isHungarianNotation(variableName, typeName)) {
-                    context.report({
-                        node,
-                        messageId: 'noHungarian',
-                        data: {
-                            name: variableName,
-                        },
-                    });
-                }
             },
-            // Handle class properties
-            PropertyDefinition(node) {
-                if (node.key.type === 'Identifier' && isClassProperty(node)) {
-                    // Skip class properties - they should be ignored
-                    return;
-                }
+            // Check type aliases
+            TSTypeAliasDeclaration(node) {
+                checkIdentifier(node.id);
+            },
+            // Check interface declarations
+            TSInterfaceDeclaration(node) {
+                checkIdentifier(node.id);
             },
         };
     },

package/lib/rules/no-uuidv4-base62-as-key.d.ts

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