@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/enforce-dynamic-file-naming.js

@@ -3,76 +3,101 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RULE_NAME = void 0;
-const createRule_1 = require("../utils/createRule");
+exports.DYNAMIC_RULES_LABEL = exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE = exports.RULE_NAME = void 0;
 const path_1 = __importDefault(require("path"));
+const createRule_1 = require("../utils/createRule");
 exports.RULE_NAME = 'enforce-dynamic-file-naming';
+const ENFORCE_DYNAMIC_IMPORTS_RULE = '@blumintinc/blumint/enforce-dynamic-imports';
+exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE = '@blumintinc/blumint/require-dynamic-firebase-imports';
+exports.DYNAMIC_RULES_LABEL = `${ENFORCE_DYNAMIC_IMPORTS_RULE} or ${exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE}`;
+const SHORTHAND_DISABLE_NEXT_LINE = /\bednl\b/;
+const SHORTHAND_DISABLE_LINE = /\bedl\b/;
+const DISABLE_NEXT_LINE_TOKEN = 'eslint-disable-next-line';
+const DISABLE_LINE_TOKEN = 'eslint-disable-line';
+const DISABLE_BLOCK_PATTERN = /\beslint-disable\b(?!-)/;
+const disabledRuleNameFrom = (commentText) => {
+    const mentionsEnforceDynamicImports = commentText.includes(ENFORCE_DYNAMIC_IMPORTS_RULE);
+    const mentionsRequireDynamicFirebaseImports = commentText.includes(exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE);
+    if (mentionsEnforceDynamicImports && mentionsRequireDynamicFirebaseImports) {
+        return exports.DYNAMIC_RULES_LABEL;
+    }
+    if (mentionsEnforceDynamicImports) {
+        return ENFORCE_DYNAMIC_IMPORTS_RULE;
+    }
+    if (mentionsRequireDynamicFirebaseImports) {
+        return exports.REQUIRE_DYNAMIC_FIREBASE_IMPORTS_RULE;
+    }
+    return null;
+};
 exports.default = (0, createRule_1.createRule)({
     name: exports.RULE_NAME,
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce .dynamic.ts(x) file naming when @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports rule is disabled',
+            description: `Enforce .dynamic.ts(x) file naming when ${exports.DYNAMIC_RULES_LABEL} rule is disabled`,
             recommended: 'error',
         },
         schema: [],
         messages: {
-            requireDynamicExtension: 'Files with disabled @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports rule must use .dynamic.ts(x) extension',
-            requireDisableDirective: 'Files with .dynamic.ts(x) extension must have at least one @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports disable directive',
+            requireDynamicExtension: 'File "{{fileName}}" disables "{{ruleName}}" but keeps the standard {{extension}} extension, hiding that dynamic-import safeguards are bypassed. Rename to "{{suggestedName}}" (or another *.dynamic.ts/tsx name) so the exception is visible and static-import hotspots stay easy to audit.',
+            requireDisableDirective: 'File "{{fileName}}" uses the ".dynamic" suffix that signals dynamic-import rules are disabled, but it lacks a disable directive for {{dynamicRulesLabel}}. Add the matching disable comment for the static import you need, or rename the file to "{{standardName}}" so the rules keep protecting other files.',
         },
     },
     defaultOptions: [],
     create(context) {
-        // Get the file path and name
         const filePath = context.getFilename();
         const fileName = path_1.default.basename(filePath);
-        // Check if the file is a TypeScript file (ends with .ts or .tsx)
-        // Ignore files with other extensions like .test.ts, .deprecated.ts, etc.
-        const isTypeScriptFile = /^[^.]+\.tsx?$/.test(fileName);
-        // Check if the file has .dynamic.ts or .dynamic.tsx extension
+        const isTypeScriptFile = fileName.endsWith('.ts') || fileName.endsWith('.tsx');
         const hasDynamicExtension = /\.dynamic\.tsx?$/.test(fileName);
-        // Skip if not a TypeScript file or has other extensions
         if (!isTypeScriptFile && !hasDynamicExtension) {
             return {};
         }
-        // Track if we found a disable directive for enforce-dynamic-imports
         let foundDisableDirective = false;
+        let disabledRuleName = null;
         return {
             Program() {
-                // Get the source code
                 const sourceCode = context.getSourceCode();
                 const comments = sourceCode.getAllComments();
-                // Check all comments for disable directives
                 for (const comment of comments) {
                     const commentText = comment.value.trim();
-                    // Check for inline disable directive for either rule
-                    if ((commentText.includes('eslint-disable-next-line') ||
-                        commentText.includes('ednl')) &&
-                        (commentText.includes('@blumintinc/blumint/enforce-dynamic-imports') ||
-                            commentText.includes('@blumintinc/blumint/require-dynamic-firebase-imports'))) {
-                        foundDisableDirective = true;
-                        break;
-                    }
-                    // Check for block disable directive for either rule
-                    if (commentText.includes('eslint-disable ') &&
-                        (commentText.includes('@blumintinc/blumint/enforce-dynamic-imports') ||
-                            commentText.includes('@blumintinc/blumint/require-dynamic-firebase-imports'))) {
+                    const disabledRuleNameForComment = disabledRuleNameFrom(commentText);
+                    const disablesTargetRule = disabledRuleNameForComment !== null;
+                    const inlineDisable = (commentText.includes(DISABLE_NEXT_LINE_TOKEN) ||
+                        commentText.includes(DISABLE_LINE_TOKEN) ||
+                        SHORTHAND_DISABLE_NEXT_LINE.test(commentText) ||
+                        SHORTHAND_DISABLE_LINE.test(commentText)) &&
+                        disablesTargetRule;
+                    const blockDisable = DISABLE_BLOCK_PATTERN.test(commentText) && disablesTargetRule;
+                    if (inlineDisable || blockDisable) {
                         foundDisableDirective = true;
+                        disabledRuleName = disabledRuleNameForComment;
                         break;
                     }
                 }
-                // If we found a disable directive but the file doesn't have .dynamic extension
                 if (foundDisableDirective && !hasDynamicExtension) {
+                    const suggestedName = fileName.replace(/\.tsx?$/, '.dynamic$&');
+                    const extension = path_1.default.extname(fileName);
                     context.report({
                         loc: { line: 1, column: 0 },
                         messageId: 'requireDynamicExtension',
+                        data: {
+                            fileName,
+                            ruleName: disabledRuleName ?? exports.DYNAMIC_RULES_LABEL,
+                            extension,
+                            suggestedName,
+                        },
                     });
                 }
-                // If the file has .dynamic extension but no disable directive
                 if (hasDynamicExtension && !foundDisableDirective) {
+                    const standardName = fileName.replace(/\.dynamic(?=\.tsx?$)/, '');
                     context.report({
                         loc: { line: 1, column: 0 },
                         messageId: 'requireDisableDirective',
+                        data: {
+                            fileName,
+                            standardName,
+                            dynamicRulesLabel: exports.DYNAMIC_RULES_LABEL,
+                        },
                     });
                 }
             },

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

@@ -7,41 +7,122 @@ exports.enforceFirebaseImports = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce dynamic importing for modules within the firebaseCloud directory to optimize initial bundle size. This ensures Firebase-related code is only loaded when needed, improving application startup time and reducing the main bundle size.',
+            description: 'Require firebaseCloud modules to be loaded via dynamic import so Firebase code stays out of the initial bundle and only loads when needed.',
             recommended: 'error',
         },
+        fixable: 'code',
+        hasSuggestions: true,
         schema: [],
         messages: {
-            noDynamicImport: 'Static imports from firebaseCloud directory are not allowed to reduce initial bundle size. Instead of `import { func } from "./firebaseCloud/module"`, use dynamic import: `const { func } = await import("./firebaseCloud/module")`.',
+            noDynamicImport: 'Static import from firebaseCloud path "{{importPath}}" eagerly bundles Firebase code into the initial client chunk, which inflates startup time and prevents lazy loading. Replace it with an awaited dynamic import so the code only loads when invoked (e.g., `const module = await import(\'{{importPath}}\')` or destructure the exports you need).',
         },
     },
     defaultOptions: [],
     create(context) {
         return {
             ImportDeclaration(node) {
-                // Skip type-only imports
+                // Skip third-party files
+                const filename = context.getFilename?.();
+                if (filename && /(^|[\\/])node_modules([\\/]|$)/.test(filename)) {
+                    return;
+                }
+                // Skip type-only import declarations
                 if (node.importKind === 'type') {
                     return;
                 }
                 const importPath = node.source.value;
                 // Check if the import is from firebaseCloud directory
-                if (importPath.includes('firebaseCloud/')) {
-                    context.report({
-                        node,
-                        messageId: 'noDynamicImport',
-                        fix(fixer) {
-                            const importSpecifiers = node.specifiers
-                                .filter((spec) => spec.type === 'ImportSpecifier')
-                                .map((spec) => spec.imported.name);
-                            if (importSpecifiers.length === 0) {
-                                return null;
-                            }
-                            const destructuredImports = `{ ${importSpecifiers.join(', ')} }`;
-                            const dynamicImport = `const ${destructuredImports} = await import('${importPath}');`;
-                            return fixer.replaceText(node, dynamicImport);
-                        },
-                    });
+                if (!importPath.includes('firebaseCloud/')) {
+                    return;
                 }
+                // Determine specifiers
+                const defaultSpecifier = node.specifiers.find((spec) => spec.type === 'ImportDefaultSpecifier');
+                const namespaceSpecifier = node.specifiers.find((spec) => spec.type === 'ImportNamespaceSpecifier');
+                const namedSpecifiers = node.specifiers.filter((spec) => spec.type === 'ImportSpecifier' && spec.importKind !== 'type');
+                const typeOnlySpecifiers = node.specifiers.filter((spec) => spec.type === 'ImportSpecifier' && spec.importKind === 'type');
+                // If there are only type-only specifiers, allow
+                if (!defaultSpecifier &&
+                    !namespaceSpecifier &&
+                    namedSpecifiers.length === 0 &&
+                    typeOnlySpecifiers.length > 0) {
+                    return;
+                }
+                const buildTypeNames = () => typeOnlySpecifiers
+                    .map((spec) => spec.imported.name === spec.local.name
+                    ? spec.imported.name
+                    : `${spec.imported.name} as ${spec.local.name}`)
+                    .join(', ');
+                const buildReplacement = (options = {}) => {
+                    const statements = [];
+                    if (typeOnlySpecifiers.length > 0) {
+                        statements.push(`import type { ${buildTypeNames()} } from '${importPath}';`);
+                    }
+                    if (namespaceSpecifier) {
+                        const nsLocal = namespaceSpecifier.local.name;
+                        statements.push(`const ${nsLocal} = await import('${importPath}');`);
+                        if (defaultSpecifier) {
+                            const defLocal = defaultSpecifier.local.name;
+                            statements.push(`const ${defLocal} = ${nsLocal}.default;`);
+                        }
+                        const destructureFromNamespace = [];
+                        if (namedSpecifiers.length > 0) {
+                            const destructureParts = namedSpecifiers.map((spec) => {
+                                const imported = spec.imported.name;
+                                const local = spec.local.name;
+                                return imported === local ? imported : `${imported}: ${local}`;
+                            });
+                            destructureFromNamespace.push(...destructureParts);
+                        }
+                        if (destructureFromNamespace.length > 0) {
+                            statements.push(`const { ${destructureFromNamespace.join(', ')} } = ${nsLocal};`);
+                        }
+                        return statements.join(' ');
+                    }
+                    const destructureParts = [];
+                    if (defaultSpecifier) {
+                        const defLocal = defaultSpecifier.local.name;
+                        destructureParts.push(`default: ${defLocal}`);
+                    }
+                    if (namedSpecifiers.length > 0) {
+                        for (const spec of namedSpecifiers) {
+                            const imported = spec.imported.name;
+                            const local = spec.local.name;
+                            destructureParts.push(imported === local ? imported : `${imported}: ${local}`);
+                        }
+                    }
+                    if (destructureParts.length > 0) {
+                        statements.push(`const { ${destructureParts.join(', ')} } = await import('${importPath}');`);
+                        return statements.join(' ');
+                    }
+                    if (node.specifiers.length === 0) {
+                        return options.allowSideEffectFix !== false
+                            ? `await import('${importPath}');`
+                            : null;
+                    }
+                    return null;
+                };
+                context.report({
+                    node,
+                    messageId: 'noDynamicImport',
+                    data: { importPath },
+                    fix(fixer) {
+                        const replacement = buildReplacement();
+                        return replacement ? fixer.replaceText(node, replacement) : null;
+                    },
+                    suggest: [
+                        {
+                            messageId: 'noDynamicImport',
+                            fix(fixer) {
+                                const replacement = buildReplacement({
+                                    allowSideEffectFix: true,
+                                });
+                                return replacement
+                                    ? fixer.replaceText(node, replacement)
+                                    : null;
+                            },
+                        },
+                    ],
+                });
             },
         };
     },

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

@@ -29,7 +29,7 @@ exports.default = (0, createRule_1.createRule)({
             },
         ],
         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))',
+            dynamicImportRequired: 'Static import from "{{source}}" eagerly pulls the entire package into the entry bundle, inflating download size and delaying the first render. Load it lazily with a dynamic import (for example, useDynamic(() => import("{{source}}"))) so the code is fetched only when needed; if you only need types, use a type-only import with allowImportType enabled.',
         },
     },
     defaultOptions: [

package/lib/rules/enforce-early-destructuring.d.ts

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