@blumintinc/eslint-plugin-blumint 1.7.3 → 1.8.1

package/lib/rules/enforce-dynamic-imports.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.RULE_NAME = 'enforce-dynamic-imports';
+exports.default = (0, createRule_1.createRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce dynamic imports for specified libraries to optimize bundle size',
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    libraries: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    allowImportType: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            dynamicImportRequired: 'Static imports from "{{source}}" are not allowed to reduce initial bundle size. Use dynamic imports instead: const Component = useDynamic(() => import("{{source}}").then(mod => mod.Component))',
+        },
+    },
+    defaultOptions: [
+        {
+            libraries: ['@stream-io/video-react-sdk'],
+            allowImportType: true,
+        },
+    ],
+    create(context, [options]) {
+        const { libraries, allowImportType = true } = options;
+        // Check if the import source matches any of the specified libraries
+        const isLibraryMatch = (source) => {
+            return libraries.some((lib) => {
+                // Simple glob pattern matching
+                if (lib.includes('*')) {
+                    const pattern = lib.replace(/\*/g, '.*');
+                    const regex = new RegExp(`^${pattern}$`);
+                    return regex.test(source);
+                }
+                return source === lib;
+            });
+        };
+        return {
+            ImportDeclaration(node) {
+                const importSource = node.source.value;
+                // Skip type-only imports if allowed
+                if (allowImportType) {
+                    // Check if it's a type-only import declaration
+                    if (node.importKind === 'type') {
+                        return;
+                    }
+                    // Check if all specifiers are type imports
+                    if (node.specifiers.length > 0 &&
+                        node.specifiers.every(spec => (spec.type === 'ImportSpecifier' && spec.importKind === 'type'))) {
+                        return;
+                    }
+                }
+                // Check if the import is from a library that should be dynamically imported
+                if (typeof importSource === 'string' && isLibraryMatch(importSource)) {
+                    context.report({
+                        node,
+                        messageId: 'dynamicImportRequired',
+                        data: {
+                            source: importSource,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-dynamic-imports.js.map

package/lib/rules/enforce-firestore-facade.js

@@ -27,6 +27,10 @@ const isFirestoreMethodCall = (node) => {
             return true;
         }
     }
+    // Handle type assertions (as in the bug report)
+    if (object.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+        return true;
+    }
     // Check if it's a Firestore reference
     let current = object;
     let foundDocOrCollection = false;
@@ -44,6 +48,10 @@ const isFirestoreMethodCall = (node) => {
         if (isMemberExpression(current)) {
             current = current.object;
         }
+        else if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+            // Handle nested type assertions
+            current = current.expression;
+        }
         else {
             break;
         }

package/lib/rules/enforce-id-capitalization.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This rule ensures consistency in user-facing text by enforcing the use of "ID"
+ * instead of "id" when referring to identifiers in UI labels, instructions,
+ * error messages, and other visible strings.
+ */
+export declare const enforceIdCapitalization: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"enforceIdCapitalization", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/enforce-id-capitalization.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceIdCapitalization = void 0;
+const createRule_1 = require("../utils/createRule");
+/**
+ * This rule ensures consistency in user-facing text by enforcing the use of "ID"
+ * instead of "id" when referring to identifiers in UI labels, instructions,
+ * error messages, and other visible strings.
+ */
+exports.enforceIdCapitalization = (0, createRule_1.createRule)({
+    name: 'enforce-id-capitalization',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce the use of "ID" instead of "id" in user-facing text',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            enforceIdCapitalization: 'Use "ID" instead of "id" in user-facing text for better readability',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Regular expression to match standalone "id" surrounded by whitespace or punctuation
+        // This ensures we only match "id" as a word, not as part of another word
+        const idRegex = /(^|\s|[.,;:!?'"()\[\]{}])id(\s|$|[.,;:!?'"()\[\]{}])/g;
+        /**
+         * Check if a string contains "id" as a standalone word and report if found
+         */
+        function checkForIdInString(node, value) {
+            if (typeof value !== 'string')
+                return;
+            // Reset the regex lastIndex to ensure consistent behavior
+            idRegex.lastIndex = 0;
+            // Check if the string contains "id" as a standalone word
+            if (idRegex.test(value)) {
+                // Reset the regex lastIndex again before replacing
+                idRegex.lastIndex = 0;
+                const fixedText = value.replace(idRegex, (_match, prefix, suffix) => {
+                    return `${prefix}ID${suffix}`;
+                });
+                context.report({
+                    node,
+                    messageId: 'enforceIdCapitalization',
+                    fix: (fixer) => {
+                        if (node.type === 'Literal') {
+                            return fixer.replaceText(node, JSON.stringify(fixedText));
+                        }
+                        else if (node.type === 'JSXText') {
+                            return fixer.replaceText(node, fixedText);
+                        }
+                        else if (node.type === 'TemplateElement') {
+                            return fixer.replaceText(node, fixedText);
+                        }
+                        return fixer.replaceText(node, JSON.stringify(fixedText));
+                    },
+                });
+            }
+        }
+        return {
+            // Check string literals
+            Literal(node) {
+                if (typeof node.value === 'string') {
+                    checkForIdInString(node, node.value);
+                }
+            },
+            // Check JSX text
+            JSXText(node) {
+                checkForIdInString(node, node.value);
+            },
+            // We don't need a separate handler for CallExpression since we already handle Literals
+            // The Literal handler will catch the string arguments in t("user.profile.id")
+        };
+    },
+});
+//# sourceMappingURL=enforce-id-capitalization.js.map

package/lib/rules/enforce-microdiff.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'enforceMicrodiff' | 'enforceMicrodiffImport';
+export declare const enforceMicrodiff: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/enforce-microdiff.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceMicrodiff = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.enforceMicrodiff = (0, createRule_1.createRule)({
+    name: 'enforce-microdiff',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce using microdiff for object and array comparison operations',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            enforceMicrodiff: 'Use the microdiff library for object and array comparison operations',
+            enforceMicrodiffImport: 'Import diff from microdiff instead of {{importSource}}',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        const importedDiffLibraries = new Map();
+        const importedFunctions = new Map(); // Map of imported function names to their sources
+        let hasMicrodiffImport = false;
+        const reportedNodes = new Set();
+        // Add a specific set to track which import names are used
+        const usedImportNames = new Set();
+        // Check if a node is an object or array type
+        function isObjectOrArrayType(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
+                node.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return true;
+            }
+            // For identifiers, we'll make a simple assumption based on naming conventions
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const name = node.name.toLowerCase();
+                // Names that likely represent objects or arrays
+                if (name.includes('obj') ||
+                    name.includes('config') ||
+                    name.includes('options') ||
+                    name.includes('data') ||
+                    name.includes('state') ||
+                    name.includes('props') ||
+                    name.includes('items') ||
+                    name.includes('array') ||
+                    name.includes('list') ||
+                    name.endsWith('s')) {
+                    return true;
+                }
+            }
+            // For member expressions, assume they could be objects/arrays
+            if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                return true;
+            }
+            return false;
+        }
+        return {
+            // Track imports of diffing libraries
+            ImportDeclaration(node) {
+                const importSource = node.source.value;
+                // Check for microdiff import
+                if (importSource === 'microdiff') {
+                    hasMicrodiffImport = true;
+                    return;
+                }
+                // Track other diffing libraries
+                if ([
+                    'deep-diff',
+                    'fast-diff',
+                    'diff',
+                    'deep-object-diff',
+                    'fast-deep-equal',
+                    'fast-deep-equal/es6',
+                ].includes(importSource)) {
+                    // Track imported function names and their sources
+                    node.specifiers.forEach((specifier) => {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            (specifier.imported.name === 'diff' ||
+                                specifier.imported.name === 'diffArrays' ||
+                                specifier.imported.name === 'detailedDiff')) {
+                            // Track the local name (which could be different due to renaming)
+                            const localName = specifier.local.name;
+                            importedFunctions.set(localName, importSource);
+                        }
+                        else if (importSource === 'fast-deep-equal' ||
+                            importSource === 'fast-deep-equal/es6') {
+                            // Handle default imports for fast-deep-equal
+                            if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                                importedFunctions.set(specifier.local.name, importSource);
+                            }
+                        }
+                    });
+                    // Report all competing diffing libraries right away
+                    context.report({
+                        node,
+                        messageId: 'enforceMicrodiffImport',
+                        data: {
+                            importSource,
+                        },
+                        fix(fixer) {
+                            // If we already have a microdiff import, just remove this import
+                            if (hasMicrodiffImport) {
+                                return fixer.remove(node);
+                            }
+                            // Otherwise, replace with microdiff import
+                            return fixer.replaceText(node, `import { diff } from 'microdiff';`);
+                        },
+                    });
+                    // Check if importing a diff function or a known equality library
+                    const hasDiffImport = node.specifiers.some((specifier) => {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                            return (specifier.imported.name === 'diff' ||
+                                specifier.imported.name === 'diffArrays' ||
+                                specifier.imported.name === 'detailedDiff');
+                        }
+                        return false;
+                    });
+                    if (hasDiffImport ||
+                        importSource === 'fast-deep-equal' ||
+                        importSource === 'fast-deep-equal/es6') {
+                        importedDiffLibraries.set(importSource, node);
+                    }
+                }
+            },
+            // Check for usage of other diffing libraries
+            CallExpression(node) {
+                // Skip if we've already reported this node
+                if (reportedNodes.has(node)) {
+                    return;
+                }
+                const { callee } = node;
+                // Check for direct calls to imported diff functions
+                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const name = callee.name;
+                    // Check if this is a function we specifically imported from a diff library
+                    if (importedFunctions.has(name)) {
+                        usedImportNames.add(name);
+                        // Always report it if it's from a tracked library
+                        reportedNodes.add(node);
+                        context.report({
+                            node,
+                            messageId: 'enforceMicrodiff',
+                            fix(fixer) {
+                                return fixer.replaceText(callee, 'diff');
+                            },
+                        });
+                        return;
+                    }
+                    // Check known diff function names
+                    const isDiffFunction = [
+                        'deepDiff',
+                        'fastDiff',
+                        'diffArrays',
+                        'detailedDiff',
+                        'fastDeepEqual',
+                        'isEqual',
+                    ].includes(name);
+                    if (isDiffFunction) {
+                        // Track this import name as used
+                        usedImportNames.add(name);
+                        // Check if we have at least 2 arguments that are objects or arrays
+                        if (node.arguments.length >= 2 &&
+                            isObjectOrArrayType(node.arguments[0]) &&
+                            isObjectOrArrayType(node.arguments[1])) {
+                            reportedNodes.add(node);
+                            context.report({
+                                node,
+                                messageId: 'enforceMicrodiff',
+                                fix(fixer) {
+                                    // When handling fast-diff and similar libraries, need to ensure the function name is replaced
+                                    return fixer.replaceText(callee, 'diff');
+                                },
+                            });
+                        }
+                    }
+                }
+                // Check for lodash difference functions
+                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.object.name === '_') {
+                    const property = callee.property;
+                    if (property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        ['difference', 'differenceBy', 'differenceWith'].includes(property.name)) {
+                        reportedNodes.add(node);
+                        context.report({
+                            node,
+                            messageId: 'enforceMicrodiff',
+                            fix(fixer) {
+                                // Replace with microdiff
+                                return fixer.replaceText(node, `diff(${node.arguments
+                                    .map((arg) => sourceCode.getText(arg))
+                                    .join(', ')})`);
+                            },
+                        });
+                    }
+                }
+            },
+            // Check for manual object comparison patterns
+            BinaryExpression(node) {
+                // Skip if we've already reported this node or its parent function
+                if (reportedNodes.has(node)) {
+                    return;
+                }
+                // Find the parent function or method
+                let current = node;
+                while (current &&
+                    current.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+                    current.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    current = current.parent;
+                }
+                // If we already reported the parent function, skip this node
+                if (current && reportedNodes.has(current)) {
+                    return;
+                }
+                // Check for JSON.stringify comparison pattern
+                if ((node.operator === '===' || node.operator === '!==') &&
+                    node.left.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.right.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const isJsonStringify = (expr) => {
+                        return (expr.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                            expr.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            expr.callee.object.name === 'JSON' &&
+                            expr.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            expr.callee.property.name === 'stringify');
+                    };
+                    if (isJsonStringify(node.left) && isJsonStringify(node.right)) {
+                        const leftArg = node.left.arguments[0];
+                        const rightArg = node.right.arguments[0];
+                        if (isObjectOrArrayType(leftArg) && isObjectOrArrayType(rightArg)) {
+                            reportedNodes.add(node);
+                            const isEqual = node.operator === '===';
+                            context.report({
+                                node,
+                                messageId: 'enforceMicrodiff',
+                                fix(fixer) {
+                                    // Find the containing function to add the import
+                                    let functionNode = node;
+                                    while (functionNode &&
+                                        functionNode.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+                                        functionNode.type !==
+                                            utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                                        functionNode.type !== utils_1.AST_NODE_TYPES.Program) {
+                                        functionNode = functionNode.parent;
+                                    }
+                                    // If we found a program node and microdiff isn't imported,
+                                    // we'll need to add the import manually
+                                    if (functionNode &&
+                                        functionNode.type === utils_1.AST_NODE_TYPES.Program &&
+                                        !hasMicrodiffImport) {
+                                        // Need to add an import
+                                        const importFix = fixer.insertTextBeforeRange([0, 0], "import { diff } from 'microdiff';\n\n");
+                                        // Replace JSON.stringify comparison
+                                        const compareFix = fixer.replaceText(node, `diff(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
+                                        return [importFix, compareFix];
+                                    }
+                                    // Otherwise just replace the comparison
+                                    return fixer.replaceText(node, `diff(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+            // Check for custom deep comparison functions
+            FunctionDeclaration(node) {
+                // Skip if we've already reported this node
+                if (reportedNodes.has(node)) {
+                    return;
+                }
+                // Look for functions that might be implementing diff logic
+                if (node.id &&
+                    [
+                        'detectChanges',
+                        'hasConfigChanged',
+                        'compareObjects',
+                        'compareArrays',
+                        'findChanges',
+                        'detectDifferences',
+                        'hasStateChanged',
+                        'stateHasUpdated',
+                        'arrayHasChanged',
+                        'settingsChanged',
+                    ].includes(node.id.name)) {
+                    // Check if function has two parameters that might be objects/arrays
+                    if (node.params.length >= 2) {
+                        const body = node.body;
+                        const bodyText = sourceCode.getText(body);
+                        // Check if the function body contains a JSON.stringify comparison
+                        if (node.id.name === 'hasConfigChanged' &&
+                            bodyText.includes('JSON.stringify') &&
+                            bodyText.includes('!==')) {
+                            reportedNodes.add(node);
+                            const param1 = sourceCode.getText(node.params[0]);
+                            const param2 = sourceCode.getText(node.params[1]);
+                            context.report({
+                                node,
+                                messageId: 'enforceMicrodiff',
+                                fix(fixer) {
+                                    // Create a new version of the function with microdiff
+                                    const newFunctionBody = `{
+  return diff(${param1}, ${param2}).length > 0;
+}`;
+                                    if (!hasMicrodiffImport) {
+                                        // Create a new import statement
+                                        return fixer.replaceText(node, `import { diff } from 'microdiff';\n\nfunction ${node.id?.name}(${param1}, ${param2}) ${newFunctionBody}`);
+                                    }
+                                    else {
+                                        // Just replace the function body
+                                        return fixer.replaceText(body, newFunctionBody);
+                                    }
+                                },
+                            });
+                            return;
+                        }
+                        // Look for patterns that suggest object/array comparison
+                        const hasComparisonLogic = bodyText.includes('JSON.stringify') ||
+                            bodyText.includes('Object.keys') ||
+                            bodyText.includes('for (') ||
+                            bodyText.includes('.some(') ||
+                            bodyText.includes('.every(');
+                        if (hasComparisonLogic) {
+                            reportedNodes.add(node);
+                            context.report({
+                                node,
+                                messageId: 'enforceMicrodiff',
+                            });
+                        }
+                    }
+                }
+            },
+            // Check for custom deep comparison in arrow functions
+            ArrowFunctionExpression(node) {
+                // Skip if we've already reported this node
+                if (reportedNodes.has(node)) {
+                    return;
+                }
+                // Only check arrow functions assigned to variables with comparison-like names
+                const parent = node.parent;
+                if (parent &&
+                    parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    [
+                        'detectChanges',
+                        'hasConfigChanged',
+                        'compareObjects',
+                        'compareArrays',
+                        'findChanges',
+                        'detectDifferences',
+                        'hasStateChanged',
+                        'stateHasUpdated',
+                        'arrayHasChanged',
+                        'settingsChanged',
+                    ].includes(parent.id.name)) {
+                    // Check if function has two parameters that might be objects/arrays
+                    if (node.params.length >= 2) {
+                        const body = node.body;
+                        // Look for patterns that suggest object/array comparison
+                        const bodyText = sourceCode.getText(body);
+                        const hasComparisonLogic = bodyText.includes('JSON.stringify') ||
+                            bodyText.includes('Object.keys') ||
+                            bodyText.includes('for (') ||
+                            bodyText.includes('.some(') ||
+                            bodyText.includes('.every(');
+                        if (hasComparisonLogic) {
+                            reportedNodes.add(node);
+                            context.report({
+                                node,
+                                messageId: 'enforceMicrodiff',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-microdiff.js.map

package/lib/rules/enforce-mui-rounded-icons.d.ts

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

package/lib/rules/enforce-mui-rounded-icons.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceMuiRoundedIcons = void 0;
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+exports.enforceMuiRoundedIcons = (0, createRule_1.createRule)({
+    name: 'enforce-mui-rounded-icons',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce the use of -Rounded variant for MUI icons',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            enforceRoundedVariant: 'Use the -Rounded variant for MUI icons (e.g., LogoutRounded instead of Logout)',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                // Only check imports from @mui/icons-material
+                if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.source.value === 'string' &&
+                    node.source.value.startsWith('@mui/icons-material/')) {
+                    const iconPath = node.source.value;
+                    // Skip if already using -Rounded variant
+                    if (iconPath.endsWith('Rounded')) {
+                        return;
+                    }
+                    // Extract the icon name from the path
+                    const iconName = iconPath.split('/').pop();
+                    // Skip if the icon name is not a string (shouldn't happen)
+                    if (!iconName) {
+                        return;
+                    }
+                    // Create the rounded variant name
+                    const roundedVariant = `${iconName}Rounded`;
+                    context.report({
+                        node,
+                        messageId: 'enforceRoundedVariant',
+                        fix: (fixer) => {
+                            // Replace the import path with the rounded variant
+                            return fixer.replaceText(node.source, `'@mui/icons-material/${roundedVariant}'`);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-mui-rounded-icons.js.map

package/lib/rules/enforce-object-literal-as-const.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export declare const enforceObjectLiteralAsConst: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"enforceAsConst", never[], {
+    ReturnStatement(node: TSESTree.ReturnStatement): void;
+}>;