@blumintinc/eslint-plugin-blumint 1.11.0 → 1.11.1

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.11.1',
     },
     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-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/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.11.1",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",