@blumintinc/eslint-plugin-blumint 1.0.5 → 1.1.1

package/lib/rules/enforce-serializable-params.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const NON_SERIALIZABLE_TYPES = new Set([
+    'Date',
+    'DocumentReference',
+    'Timestamp',
+    'Map',
+    'Set',
+    'Symbol',
+    'Function',
+    'undefined',
+]);
+exports.default = (0, createRule_1.createRule)({
+    name: 'enforce-serializable-params',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce serializable parameters in Firebase Callable/HTTPS Cloud Functions',
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    additionalNonSerializableTypes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    functionTypes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: ['CallableRequest'],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            nonSerializableParam: 'Parameter type "{{ type }}" is not serializable',
+            nonSerializableProperty: 'Property "{{ prop }}" has non-serializable type "{{ type }}"',
+        },
+    },
+    defaultOptions: [
+        {
+            additionalNonSerializableTypes: [],
+            functionTypes: ['CallableRequest'],
+        },
+    ],
+    create(context, [options]) {
+        const allNonSerializableTypes = new Set([
+            ...NON_SERIALIZABLE_TYPES,
+            ...(options.additionalNonSerializableTypes || []),
+        ]);
+        const typeAliasMap = new Map();
+        function isNonSerializableType(typeName) {
+            return allNonSerializableTypes.has(typeName);
+        }
+        function checkTypeNode(node, propName) {
+            if (!node)
+                return;
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.TSTypeReference: {
+                    const typeName = node.typeName.name;
+                    if (isNonSerializableType(typeName)) {
+                        context.report({
+                            node,
+                            messageId: propName
+                                ? 'nonSerializableProperty'
+                                : 'nonSerializableParam',
+                            data: {
+                                type: typeName,
+                                prop: propName,
+                            },
+                        });
+                    }
+                    // Check type parameters of generic types (like Array<T>)
+                    if (node.typeParameters) {
+                        node.typeParameters.params.forEach((param) => checkTypeNode(param, propName));
+                    }
+                    break;
+                }
+                case utils_1.AST_NODE_TYPES.TSArrayType:
+                    checkTypeNode(node.elementType, propName);
+                    break;
+                case utils_1.AST_NODE_TYPES.TSTypeAnnotation:
+                    checkTypeNode(node.typeAnnotation, propName);
+                    break;
+                case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+                    node.members.forEach((member) => {
+                        if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature) {
+                            const propertyName = member.key.name;
+                            checkTypeNode(member.typeAnnotation, propertyName);
+                        }
+                    });
+                    break;
+                case utils_1.AST_NODE_TYPES.TSUnionType:
+                    node.types.forEach((type) => checkTypeNode(type, propName));
+                    break;
+            }
+        }
+        return {
+            TSTypeAliasDeclaration(node) {
+                typeAliasMap.set(node.id.name, node);
+            },
+            TSTypeReference(node) {
+                const typeName = node.typeName.name;
+                if (options.functionTypes.includes(typeName) &&
+                    node.typeParameters?.params[0]) {
+                    const typeParam = node.typeParameters.params[0];
+                    if (typeParam.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                        const referencedTypeName = typeParam.typeName.name;
+                        const typeAlias = typeAliasMap.get(referencedTypeName);
+                        if (typeAlias) {
+                            checkTypeNode(typeAlias.typeAnnotation);
+                        }
+                    }
+                    else {
+                        checkTypeNode(typeParam);
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-serializable-params.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.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from '@typescript-eslint/utils';
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"upperSnakeCase" | "asConst", never[], {
+    VariableDeclaration(node: TSESTree.VariableDeclaration): void;
+}>;
+export default _default;

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const isUpperSnakeCase = (str) => /^[A-Z][A-Z0-9_]*$/.test(str);
+exports.default = (0, createRule_1.createRule)({
+    name: 'global-const-style',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce UPPER_SNAKE_CASE and as const for global static constants',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            upperSnakeCase: 'Global constants should be in UPPER_SNAKE_CASE',
+            asConst: 'Global constants should use "as const"',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            VariableDeclaration(node) {
+                // Only check top-level const declarations
+                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) => {
+                    // Skip destructuring patterns
+                    if (declaration.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                        return;
+                    }
+                    const { name } = declaration.id;
+                    const init = declaration.init;
+                    // Skip if no initializer or if it's a dynamic value
+                    if (!init ||
+                        init.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                        init.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+                        return;
+                    }
+                    // Check for UPPER_SNAKE_CASE
+                    if (!isUpperSnakeCase(name)) {
+                        context.report({
+                            node: declaration.id,
+                            messageId: 'upperSnakeCase',
+                            fix(fixer) {
+                                const newName = name
+                                    .replace(/([A-Z])/g, '_$1')
+                                    .toUpperCase()
+                                    .replace(/^_/, '');
+                                return fixer.replaceText(declaration.id, newName);
+                            },
+                        });
+                    }
+                    // Check for as 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',
+                            fix(fixer) {
+                                const sourceCode = context.getSourceCode();
+                                const initText = sourceCode.getText(init);
+                                return fixer.replaceText(init, `${initText} as const`);
+                            },
+                        });
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=global-const-style.js.map

package/lib/rules/no-jsx-whitespace-literal.d.ts

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

package/lib/rules/no-jsx-whitespace-literal.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noJsxWhitespaceLiteral = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.noJsxWhitespaceLiteral = (0, createRule_1.createRule)({
+    name: 'no-jsx-whitespace-literal',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow the use of {" "} elements in JSX code',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noWhitespaceLiteral: 'Avoid using {" "} for spacing in JSX. Use proper text nodes or CSS spacing instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXExpressionContainer(node) {
+                if (node.expression.type === 'Literal' &&
+                    typeof node.expression.value === 'string' &&
+                    node.expression.value.trim() === '') {
+                    context.report({
+                        node,
+                        messageId: 'noWhitespaceLiteral',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-jsx-whitespace-literal.js.map

package/lib/rules/no-unused-props.d.ts

@@ -0,0 +1,6 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export declare const noUnusedProps: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unusedProp", never[], {
+    TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void;
+    VariableDeclaration(node: TSESTree.VariableDeclaration): void;
+    'VariableDeclaration:exit'(node: never): void;
+}>;

package/lib/rules/no-unused-props.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnusedProps = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noUnusedProps = (0, createRule_1.createRule)({
+    name: 'no-unused-props',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Detect unused props in React component type definitions',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unusedProp: 'Prop "{{propName}}" is defined in type but not used in component',
+        },
+        fixable: 'code',
+    },
+    defaultOptions: [],
+    create(context) {
+        const propsTypes = new Map();
+        const usedProps = new Map();
+        let currentComponent = null;
+        return {
+            TSTypeAliasDeclaration(node) {
+                if (node.id.name.endsWith('Props')) {
+                    if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                        const props = {};
+                        node.typeAnnotation.members.forEach((member) => {
+                            if (member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                                member.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                props[member.key.name] = member.key;
+                            }
+                        });
+                        propsTypes.set(node.id.name, props);
+                    }
+                }
+            },
+            VariableDeclaration(node) {
+                if (node.declarations.length === 1) {
+                    const declaration = node.declarations[0];
+                    if (declaration.init?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                        const param = declaration.init.params[0];
+                        if (param?.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+                            param.typeAnnotation?.typeAnnotation.type ===
+                                utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            param.typeAnnotation.typeAnnotation.typeName.type ===
+                                utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = param.typeAnnotation.typeAnnotation.typeName.name;
+                            if (typeName.endsWith('Props')) {
+                                currentComponent = { node, typeName };
+                                const used = new Set();
+                                param.properties.forEach((prop) => {
+                                    if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                                        prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        used.add(prop.key.name);
+                                    }
+                                });
+                                usedProps.set(typeName, used);
+                            }
+                        }
+                    }
+                }
+            },
+            'VariableDeclaration:exit'(node) {
+                if (currentComponent?.node === node) {
+                    const { typeName } = currentComponent;
+                    const propsType = propsTypes.get(typeName);
+                    const used = usedProps.get(typeName);
+                    if (propsType && used) {
+                        Object.keys(propsType).forEach((prop) => {
+                            if (!used.has(prop)) {
+                                context.report({
+                                    node: propsType[prop],
+                                    messageId: 'unusedProp',
+                                    data: { propName: prop },
+                                });
+                            }
+                        });
+                    }
+                    // Reset state for this component
+                    propsTypes.delete(typeName);
+                    usedProps.delete(typeName);
+                    currentComponent = null;
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unused-props.js.map

package/lib/rules/require-dynamic-firebase-imports.d.ts

@@ -0,0 +1,6 @@
+import { TSESTree } from '@typescript-eslint/utils';
+export declare const RULE_NAME = "require-dynamic-firebase-imports";
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireDynamicImport", never[], {
+    ImportDeclaration(node: TSESTree.ImportDeclaration): void;
+}>;
+export default _default;

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.RULE_NAME = 'require-dynamic-firebase-imports';
+exports.default = (0, createRule_1.createRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce dynamic imports for Firebase dependencies',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            requireDynamicImport: 'Firebase dependencies must be imported dynamically to reduce bundle size',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const isFirebaseImport = (source) => {
+            return (source.startsWith('firebase/') ||
+                source.includes('config/firebase-client'));
+        };
+        const createDynamicImport = (node) => {
+            const importSource = node.source.value;
+            const importSpecifiers = node.specifiers;
+            if (importSpecifiers.length === 0) {
+                // For side-effect imports like 'firebase/auth'
+                return `await import('${importSource}');`;
+            }
+            if (importSpecifiers.length === 1) {
+                const spec = importSpecifiers[0];
+                if (spec.type === 'ImportDefaultSpecifier') {
+                    // For default imports
+                    return `const ${spec.local.name} = (await import('${importSource}')).default;`;
+                }
+                if (spec.type === 'ImportSpecifier') {
+                    // For single named import
+                    const importedName = spec.imported.name;
+                    const localName = spec.local.name;
+                    if (importedName === localName) {
+                        return `const { ${localName} } = await import('${importSource}');`;
+                    }
+                    return `const { ${importedName}: ${localName} } = await import('${importSource}');`;
+                }
+            }
+            // For multiple named imports
+            const importedModule = `await import('${importSource}')`;
+            const namedImports = importSpecifiers
+                .map((spec) => {
+                if (spec.type === 'ImportSpecifier') {
+                    const importedName = spec.imported.name;
+                    const localName = spec.local.name;
+                    return importedName === localName
+                        ? localName
+                        : `${importedName}: ${localName}`;
+                }
+                return '';
+            })
+                .filter(Boolean)
+                .join(', ');
+            return `const { ${namedImports} } = ${importedModule};`;
+        };
+        return {
+            ImportDeclaration(node) {
+                const importSource = node.source.value;
+                if (typeof importSource === 'string' &&
+                    isFirebaseImport(importSource) &&
+                    !node.importKind?.includes('type')) {
+                    context.report({
+                        node,
+                        messageId: 'requireDynamicImport',
+                        fix(fixer) {
+                            const dynamicImport = createDynamicImport(node);
+                            return fixer.replaceText(node, dynamicImport);
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-dynamic-firebase-imports.js.map

package/lib/rules/require-https-error.d.ts

@@ -0,0 +1,6 @@
+import { TSESTree } from '@typescript-eslint/utils';
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"useHttpsError" | "useProprietaryHttpsError", never[], {} | {
+    ImportDeclaration(node: TSESTree.ImportDeclaration): void;
+    ThrowStatement(node: TSESTree.ThrowStatement): void;
+}>;
+export = _default;

package/lib/rules/require-https-error.js

@@ -0,0 +1,74 @@
+"use strict";
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+module.exports = (0, createRule_1.createRule)({
+    name: 'require-https-error',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce using proprietary HttpsError instead of throw new Error or firebase-admin HttpsError in functions/src',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            useHttpsError: 'Use HttpsError instead of throw new Error in functions/src directory',
+            useProprietaryHttpsError: 'Use our proprietary HttpsError instead of firebase-admin HttpsError',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.getFilename();
+        // Only apply rule to files in functions/src directory
+        if (!filename.includes('functions/src')) {
+            return {};
+        }
+        let hasFirebaseAdminImport = false;
+        let httpsIdentifier = null;
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'firebase-admin' ||
+                    node.source.value === 'firebase-admin/lib/https-error') {
+                    hasFirebaseAdminImport = true;
+                    // Track the local name of the https import
+                    const httpsSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        spec.imported.name === 'https');
+                    if (httpsSpecifier && 'local' in httpsSpecifier) {
+                        httpsIdentifier = httpsSpecifier.local.name;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'useProprietaryHttpsError',
+                    });
+                }
+            },
+            ThrowStatement(node) {
+                const argument = node.argument;
+                if (argument &&
+                    argument.type === utils_1.AST_NODE_TYPES.NewExpression &&
+                    argument.callee) {
+                    if (argument.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        argument.callee.name === 'Error') {
+                        context.report({
+                            node,
+                            messageId: 'useHttpsError',
+                        });
+                    }
+                    else if (hasFirebaseAdminImport &&
+                        ((argument.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            argument.callee.name === 'HttpsError') ||
+                            (argument.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                                argument.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                argument.callee.object.name === httpsIdentifier &&
+                                argument.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                argument.callee.property.name === 'HttpsError'))) {
+                        context.report({
+                            node,
+                            messageId: 'useProprietaryHttpsError',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-https-error.js.map

package/lib/rules/require-image-overlayed.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"useImageOverlayed", {
+    componentPath: string;
+}[], {
+    JSXElement(node: any): void;
+    ImportDeclaration(node: any): void;
+}>;
+export = _default;