@blumintinc/eslint-plugin-blumint 1.0.5 → 1.1.0

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/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,77 @@
+"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' ||
+                    node.parent?.type !== utils_1.AST_NODE_TYPES.Program) {
+                    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
+                    if (init.type !== utils_1.AST_NODE_TYPES.TSAsExpression ||
+                        init.typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeReference ||
+                        init.typeAnnotation.typeName.name !==
+                            'const') {
+                        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,84 @@
+"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)) {
+                    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;

package/lib/rules/require-image-overlayed.js

@@ -0,0 +1,80 @@
+"use strict";
+const createRule_1 = require("../utils/createRule");
+module.exports = (0, createRule_1.createRule)({
+    name: 'require-image-overlayed',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce using ImageOverlayed component instead of next/image or img tags',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    componentPath: {
+                        type: 'string',
+                        default: 'src/components/ImageOverlayed',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            useImageOverlayed: 'Use ImageOverlayed component from {{ componentPath }} instead of {{ component }}',
+        },
+    },
+    defaultOptions: [{ componentPath: 'src/components/ImageOverlayed' }],
+    create(context) {
+        const options = context.options[0] || {
+            componentPath: 'src/components/ImageOverlayed',
+        };
+        const sourceCode = context.getSourceCode();
+        return {
+            // Handle JSX img elements
+            JSXElement(node) {
+                if (node.openingElement.name.name === 'img') {
+                    context.report({
+                        node,
+                        messageId: 'useImageOverlayed',
+                        data: {
+                            componentPath: options.componentPath,
+                            component: 'img tag',
+                        },
+                        fix(fixer) {
+                            const attributes = node.openingElement.attributes
+                                .map((attr) => sourceCode.getText(attr))
+                                .join(' ');
+                            return fixer.replaceText(node, `<ImageOverlayed ${attributes} />`);
+                        },
+                    });
+                }
+            },
+            // Handle next/image imports and usage
+            ImportDeclaration(node) {
+                if (node.source.value === 'next/image' && node.specifiers.length > 0) {
+                    const imageSpecifier = node.specifiers.find((spec) => (spec.type === 'ImportDefaultSpecifier' ||
+                        spec.type === 'ImportSpecifier') &&
+                        (spec.local.name === 'Image' || spec.imported?.name === 'Image'));
+                    if (imageSpecifier) {
+                        const localName = imageSpecifier.local.name;
+                        // Report the import
+                        context.report({
+                            node,
+                            messageId: 'useImageOverlayed',
+                            data: {
+                                componentPath: options.componentPath,
+                                component: 'next/image',
+                            },
+                            fix(fixer) {
+                                return fixer.replaceText(node, `import ${localName} from '${options.componentPath}';`);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-image-overlayed.js.map

package/lib/rules/require-memo.js

@@ -45,7 +45,7 @@ const isUnmemoizedExportedFunctionComponent = (parentNode, node) => {
 };
 function isMemoImport(importPath) {
     // Match both absolute and relative paths ending with util/memo
-    return /(?:^|\/)util\/memo$/.test(importPath);
+    return /(?:^|\/|\\)util\/memo$/.test(importPath);
 }
 function checkFunction(context, node) {
     const fileName = context.getFilename();
@@ -137,7 +137,7 @@ function calculateImportPath(currentFilePath) {
     // Calculate relative path based on current file depth from src
     // Subtract 1 from depth to exclude the filename itself
     const depth = parts.length - (srcIndex + 1) - 1;
-    return '../'.repeat(depth) + 'util/memo';
+    return depth > 0 ? '../'.repeat(depth) + 'util/memo' : './util/memo';
 }
 exports.requireMemo = {
     create: (context) => ({
@@ -158,7 +158,7 @@ exports.requireMemo = {
             recommended: 'error',
         },
         messages: {
-            requireMemo: 'Component definition not wrapped in React.memo()',
+            requireMemo: 'Component definition not wrapped in memo()',
         },
         schema: [],
         fixable: 'code',

package/lib/rules/require-usememo-object-literals.d.ts

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