@blumintinc/eslint-plugin-blumint 1.1.0 → 1.1.2

package/lib/index.js

@@ -32,10 +32,11 @@ const require_https_error_1 = __importDefault(require("./rules/require-https-err
 const use_custom_router_1 = require("./rules/use-custom-router");
 const require_image_overlayed_1 = __importDefault(require("./rules/require-image-overlayed"));
 const require_usememo_object_literals_1 = require("./rules/require-usememo-object-literals");
+const enforce_safe_stringify_1 = require("./rules/enforce-safe-stringify");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.1.0',
+        version: '1.1.2',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -73,6 +74,7 @@ module.exports = {
                 '@blumintinc/blumint/use-custom-router': 'error',
                 '@blumintinc/blumint/require-image-overlayed': 'error',
                 '@blumintinc/blumint/require-usememo-object-literals': 'error',
+                '@blumintinc/blumint/enforce-safe-stringify': 'error',
             },
         },
     },
@@ -106,6 +108,7 @@ module.exports = {
         'use-custom-router': use_custom_router_1.useCustomRouter,
         'require-image-overlayed': require_image_overlayed_1.default,
         'require-usememo-object-literals': require_usememo_object_literals_1.requireUseMemoObjectLiterals,
+        'enforce-safe-stringify': enforce_safe_stringify_1.enforceStableStringify,
     },
 };
 //# sourceMappingURL=index.js.map

package/lib/rules/consistent-callback-naming.js

@@ -11,28 +11,37 @@ module.exports = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            callbackPropPrefix: 'Callback props must be prefixed with "on" (e.g., onClick, onChange)',
+            callbackPropPrefix: 'Callback props (function type props) must be prefixed with "on" (e.g., onClick, onChange)',
             callbackFunctionPrefix: 'Callback functions should not use "handle" prefix, use descriptive verb phrases instead',
         },
     },
     defaultOptions: [],
     create(context) {
+        const parserServices = context.parserServices;
+        // Check if we have access to TypeScript services
+        if (!parserServices?.program || !parserServices?.esTreeNodeToTSNodeMap) {
+            throw new Error('You have to enable the `project` setting in parser options to use this rule');
+        }
+        const checker = parserServices.program.getTypeChecker();
+        function isFunctionType(node) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return type.getCallSignatures().length > 0;
+        }
         return {
             // Check JSX attributes for callback props
             JSXAttribute(node) {
-                if (node.value &&
-                    node.value.type === 'JSXExpressionContainer' &&
+                if (node.value?.type === 'JSXExpressionContainer' &&
                     node.value.expression.type === 'Identifier') {
-                    const propName = node.name.name;
-                    const valueName = node.value.expression.name;
+                    const propName = node.name.type === 'JSXIdentifier' ? node.name.name : undefined;
                     // Skip React's built-in event handlers
-                    if (propName.match(/^on[A-Z]/)) {
+                    if (propName?.match(/^on[A-Z]/)) {
                         return;
                     }
-                    // Check if it's a function prop but doesn't follow the 'on' prefix convention
-                    if (valueName &&
-                        typeof valueName === 'string' &&
-                        (valueName.startsWith('handle') || valueName.match(/^[a-z]+[A-Z]/))) {
+                    // Check if the value is a function type
+                    if (isFunctionType(node.value.expression) &&
+                        propName &&
+                        !propName.startsWith('on')) {
                         context.report({
                             node,
                             messageId: 'callbackPropPrefix',
@@ -47,8 +56,8 @@ module.exports = (0, createRule_1.createRule)({
             },
             // Check function declarations and variable declarations for callback functions
             'FunctionDeclaration, VariableDeclarator'(node) {
-                const functionName = node.id?.name;
-                if (functionName && functionName.startsWith('handle')) {
+                const functionName = node.id?.type === 'Identifier' ? node.id.name : undefined;
+                if (functionName && functionName.startsWith('handle') && node.id) {
                     context.report({
                         node,
                         messageId: 'callbackFunctionPrefix',
@@ -61,18 +70,18 @@ module.exports = (0, createRule_1.createRule)({
                     });
                 }
             },
-            // Check object property methods
-            Property(node) {
-                if (node.method &&
+            // Check class methods and object methods
+            'MethodDefinition, Property'(node) {
+                if (node.key.type === 'Identifier' &&
                     node.key.name &&
                     node.key.name.startsWith('handle')) {
+                    const name = node.key.name;
                     context.report({
                         node: node.key,
                         messageId: 'callbackFunctionPrefix',
                         fix(fixer) {
                             // Remove 'handle' prefix and convert first character to lowercase
-                            const newName = node.key.name.slice(6).charAt(0).toLowerCase() +
-                                node.key.name.slice(7);
+                            const newName = name.slice(6).charAt(0).toLowerCase() + name.slice(7);
                             return fixer.replaceText(node.key, newName);
                         },
                     });

package/lib/rules/enforce-callable-types.js

@@ -22,8 +22,10 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const filename = context.getFilename();
-        // Only apply to .f.ts files in the callable directory
-        if (!filename.endsWith('.f.ts') || !filename.includes('/callable/')) {
+        // Only apply to .f.ts files in the callable directory, but ignore scripts directory
+        if (!filename.endsWith('.f.ts') ||
+            !filename.includes('/callable/') ||
+            filename.includes('/callable/scripts/')) {
             return {};
         }
         let hasParamsExport = false;

package/lib/rules/enforce-identifiable-firestore-type.js

@@ -64,23 +64,64 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                 if (node.id.name === folderName) {
                     hasExpectedType = true;
                     // Check if type extends Identifiable
-                    // Check if type extends Identifiable directly or through a generic type
-                    const checkIdentifiable = (type) => {
+                    const checkIdentifiableExtension = (type) => {
+                        // Check for direct Identifiable extension
                         if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                             type.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                             type.typeName.name === 'Identifiable') {
                             return true;
                         }
+                        // Check intersection types
                         if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            return type.types.some(checkIdentifiable);
+                            return type.types.some(checkIdentifiableExtension);
                         }
+                        // Check generic type parameters
                         if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                             type.typeParameters?.params) {
-                            return type.typeParameters.params.some(checkIdentifiable);
+                            return type.typeParameters.params.some(checkIdentifiableExtension);
                         }
                         return false;
                     };
-                    typeHasIdentifiable = checkIdentifiable(node.typeAnnotation);
+                    // Check if type has id: string field
+                    const checkIdField = (type) => {
+                        // Check for id: string field in type literal
+                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                            return type.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                                member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                member.key.name === 'id' &&
+                                member.typeAnnotation?.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSStringKeyword);
+                        }
+                        // Check intersection types
+                        if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return type.types.some(checkIdField);
+                        }
+                        return false;
+                    };
+                    // Check if type is wrapped in a utility type
+                    const isUtilityType = (type) => {
+                        return (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            type.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            type.typeName.name === 'Resolve');
+                    };
+                    // Recursively check the type and its parameters
+                    const checkType = (type) => {
+                        // Check if type extends Identifiable
+                        if (checkIdentifiableExtension(type)) {
+                            return true;
+                        }
+                        // Check if type has id: string field (only for utility types)
+                        if (isUtilityType(type) && checkIdField(type.typeParameters.params[0])) {
+                            return true;
+                        }
+                        // Check if type is wrapped in a utility type
+                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            type.typeParameters?.params?.[0]) {
+                            return checkType(type.typeParameters.params[0]);
+                        }
+                        // For direct type definitions, require extending Identifiable
+                        return false;
+                    };
+                    typeHasIdentifiable = checkType(node.typeAnnotation);
                 }
             },
         };

package/lib/rules/enforce-safe-stringify.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceStableStringify: TSESLint.RuleModule<"useStableStringify", [], TSESLint.RuleListener>;

package/lib/rules/enforce-safe-stringify.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceStableStringify = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceStableStringify = (0, createRule_1.createRule)({
+    name: 'enforce-safe-stringify',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce using safe-stable-stringify instead of JSON.stringify',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useStableStringify: 'Use safe-stable-stringify instead of JSON.stringify for safer serialization',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        let hasStringifyImport = false;
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'safe-stable-stringify' &&
+                    node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier &&
+                        specifier.local.name === 'stringify')) {
+                    hasStringifyImport = true;
+                }
+            },
+            MemberExpression(node) {
+                if (node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.object.name === 'JSON' &&
+                    node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.property.name === 'stringify') {
+                    context.report({
+                        node,
+                        messageId: 'useStableStringify',
+                        fix(fixer) {
+                            const fixes = [];
+                            // Add import if not present
+                            if (!hasStringifyImport) {
+                                const program = context.getSourceCode().ast;
+                                const firstImport = program.body.find((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                                const importStatement = "import stringify from 'safe-stable-stringify';\n";
+                                if (firstImport) {
+                                    fixes.push(fixer.insertTextBefore(firstImport, importStatement));
+                                }
+                                else {
+                                    fixes.push(fixer.insertTextBefore(program.body[0], importStatement));
+                                }
+                                hasStringifyImport = true;
+                            }
+                            // Replace JSON.stringify with stringify
+                            fixes.push(fixer.replaceText(node, 'stringify'));
+                            return fixes;
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-safe-stringify.js.map

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

@@ -3,6 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractGlobalConstants = void 0;
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
+function isInsideFunction(node) {
+    let current = node;
+    while (current) {
+        if (current.type === 'FunctionDeclaration' ||
+            current.type === 'FunctionExpression' ||
+            current.type === 'ArrowFunctionExpression') {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isFunctionDefinition(node) {
+    return (node?.type === 'FunctionExpression' ||
+        node?.type === 'ArrowFunctionExpression');
+}
 exports.extractGlobalConstants = (0, createRule_1.createRule)({
     create(context) {
         return {
@@ -10,13 +26,19 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                 if (node.kind !== 'const') {
                     return;
                 }
+                // Skip if any of the declarations are function definitions
+                if (node.declarations.some((d) => isFunctionDefinition(d.init))) {
+                    return;
+                }
                 const scope = context.getScope();
                 const hasDependencies = node.declarations.some((declaration) => declaration.init &&
                     ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(declaration.init));
+                // Only check function/block scoped constants without dependencies
                 if (!hasDependencies &&
-                    (scope.type === 'function' || scope.type === 'block')) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const constName = node.declarations[0].id.name;
+                    (scope.type === 'function' || scope.type === 'block') &&
+                    isInsideFunction(node)) {
+                    const constName = node.declarations[0].id
+                        .name;
                     context.report({
                         node,
                         messageId: 'extractGlobalConstants',
@@ -34,8 +56,7 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
                     const scope = context.getScope();
                     const hasDependencies = ASTHelpers_1.ASTHelpers.blockIncludesIdentifier(node.body);
                     if (!hasDependencies && scope.type === 'function') {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        const funcName = node.id.name;
+                        const funcName = node.id?.name;
                         context.report({
                             node,
                             messageId: 'extractGlobalConstants',
@@ -52,7 +73,7 @@ exports.extractGlobalConstants = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Extract constants/functions to the global scope when possible',
+            description: 'Extract static constants and functions to the global scope when possible',
             recommended: 'error',
         },
         schema: [],

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

@@ -23,8 +23,27 @@ exports.default = (0, createRule_1.createRule)({
         return {
             VariableDeclaration(node) {
                 // Only check top-level const declarations
-                if (node.kind !== 'const' ||
-                    node.parent?.type !== utils_1.AST_NODE_TYPES.Program) {
+                if (node.kind !== 'const') {
+                    return;
+                }
+                // Skip if not at program level
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.Program) {
+                    return;
+                }
+                // Skip if any declaration is a function component or arrow function
+                const shouldSkip = node.declarations.some(declaration => {
+                    if (declaration.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                        return false;
+                    }
+                    const name = declaration.id.name;
+                    const init = declaration.init;
+                    return (
+                    // Skip function components (uppercase name + arrow function)
+                    (/^[A-Z]/.test(name) && init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) ||
+                        // Skip any arrow function
+                        init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression);
+                });
+                if (shouldSkip) {
                     return;
                 }
                 node.declarations.forEach((declaration) => {
@@ -55,10 +74,24 @@ exports.default = (0, createRule_1.createRule)({
                         });
                     }
                     // Check for as const
-                    if (init.type !== utils_1.AST_NODE_TYPES.TSAsExpression ||
-                        init.typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
-                        init.typeAnnotation.typeName.name !==
-                            'const') {
+                    const isAsConstExpression = (node) => {
+                        if (node.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                            return (node.typeAnnotation?.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                node.typeAnnotation?.typeName?.name === 'const');
+                        }
+                        return false;
+                    };
+                    const shouldHaveAsConst = (node) => {
+                        // Skip if it's already an as const expression
+                        if (isAsConstExpression(node)) {
+                            return false;
+                        }
+                        // Check if it's a literal, array, or object that should have as const
+                        return (node.type === utils_1.AST_NODE_TYPES.Literal ||
+                            node.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                            node.type === utils_1.AST_NODE_TYPES.ObjectExpression);
+                    };
+                    if (shouldHaveAsConst(init)) {
                         context.report({
                             node: init,
                             messageId: 'asConst',

package/lib/rules/require-dynamic-firebase-imports.js

@@ -67,7 +67,8 @@ exports.default = (0, createRule_1.createRule)({
             ImportDeclaration(node) {
                 const importSource = node.source.value;
                 if (typeof importSource === 'string' &&
-                    isFirebaseImport(importSource)) {
+                    isFirebaseImport(importSource) &&
+                    !node.importKind?.includes('type')) {
                     context.report({
                         node,
                         messageId: 'requireDynamicImport',

package/lib/rules/require-usememo-object-literals.js

@@ -23,6 +23,11 @@ exports.requireUseMemoObjectLiterals = (0, createRule_1.createRule)({
                 if (!node.value || node.value.type !== 'JSXExpressionContainer') {
                     return;
                 }
+                // Skip if the prop name is 'sx' or ends with 'Sx'
+                const propName = node.name.name;
+                if (typeof propName === 'string' && (propName === 'sx' || propName.endsWith('Sx'))) {
+                    return;
+                }
                 const { expression } = node.value;
                 // Check if the expression is an object or array literal
                 if ((expression.type === 'ObjectExpression' ||

package/lib/utils/ASTHelpers.js

@@ -75,6 +75,9 @@ class ASTHelpers {
                 }
                 return (this.declarationIncludesIdentifier(node.object) ||
                     this.declarationIncludesIdentifier(node.property));
+            case 'ImportExpression':
+                // Dynamic imports should be considered as having dependencies
+                return true;
             case 'CallExpression':
             case 'NewExpression':
                 // For function and constructor calls, we care about both the callee and the arguments.

package/package.json

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