@blumintinc/eslint-plugin-blumint 1.0.2 → 1.0.4

package/lib/rules/export-if-in-doubt.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportIfInDoubt = void 0;
+/* eslint-disable @blumintinc/blumint/extract-global-constants */
+// import { ASTHelpers } from '../utils/ASTHelpers';
+const createRule_1 = require("../utils/createRule");
+exports.exportIfInDoubt = (0, createRule_1.createRule)({
+    name: 'export-if-in-doubt',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'All top-level const definitions, type definitions, and functions should be exported',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            exportIfInDoubt: 'Top-level const definitions, type definitions, and functions should be exported.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // List of top-level declarations
+        // List of exported identifiers
+        const topLevelDeclarations = [];
+        const exportedIdentifiers = [];
+        return {
+            'Program > VariableDeclaration > VariableDeclarator, Program > FunctionDeclaration, Program > TSTypeAliasDeclaration'(node) {
+                topLevelDeclarations.push(node);
+            },
+            ExportNamedDeclaration: (node) => {
+                if (node.specifiers) {
+                    node.specifiers.forEach((specifier) => {
+                        if (specifier.type === 'ExportSpecifier') {
+                            // Handle both normal and default export
+                            const exportedName = specifier.exported.name;
+                            if (!exportedIdentifiers.includes(exportedName)) {
+                                exportedIdentifiers.push(exportedName);
+                            }
+                            // If the specifier is a default export
+                            if (specifier.local.name !== exportedName) {
+                                const localName = specifier.local.name;
+                                if (!exportedIdentifiers.includes(localName)) {
+                                    exportedIdentifiers.push(localName);
+                                }
+                            }
+                        }
+                    });
+                }
+            },
+            'Program:exit': () => {
+                topLevelDeclarations.forEach((node) => {
+                    if ('id' in node &&
+                        node.id &&
+                        (node.type === 'VariableDeclarator' ||
+                            node.type === 'FunctionDeclaration' ||
+                            node.type === 'TSTypeAliasDeclaration') &&
+                        node.id.type === 'Identifier' &&
+                        !exportedIdentifiers.includes(node.id.name)) {
+                        context.report({
+                            node,
+                            messageId: 'exportIfInDoubt',
+                        });
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=export-if-in-doubt.js.map

package/lib/rules/extract-global-constants.d.ts

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

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractGlobalConstants = void 0;
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const createRule_1 = require("../utils/createRule");
+exports.extractGlobalConstants = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            VariableDeclaration(node) {
+                if (node.kind !== 'const') {
+                    return;
+                }
+                const scope = context.getScope();
+                const hasDependencies = node.declarations.some((declaration) => declaration.init &&
+                    ASTHelpers_1.ASTHelpers.declarationIncludesIdentifier(declaration.init));
+                if (!hasDependencies &&
+                    (scope.type === 'function' || scope.type === 'block')) {
+                    const constName = node.declarations[0].id.name;
+                    context.report({
+                        node,
+                        messageId: 'extractGlobalConstants',
+                        data: {
+                            declarationName: constName,
+                        },
+                    });
+                }
+            },
+            FunctionDeclaration(node) {
+                if (node.parent &&
+                    (node.parent.type === 'FunctionDeclaration' ||
+                        node.parent.type === 'FunctionExpression' ||
+                        node.parent.type === 'ArrowFunctionExpression')) {
+                    const scope = context.getScope();
+                    const hasDependencies = ASTHelpers_1.ASTHelpers.blockIncludesIdentifier(node.body);
+                    if (!hasDependencies && scope.type === 'function') {
+                        const funcName = node.id.name;
+                        context.report({
+                            node,
+                            messageId: 'extractGlobalConstants',
+                            data: {
+                                declarationName: funcName,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+    name: 'extract-global-constants',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Extract constants/functions to the global scope when possible',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            extractGlobalConstants: 'Move this declaration {{ declarationName }} to the global scope and rename it to UPPER_SNAKE_CASE if necessary.',
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=extract-global-constants.js.map

package/lib/rules/generic-starts-with-t.d.ts

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

package/lib/rules/generic-starts-with-t.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericStartsWithT = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.genericStartsWithT = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            TSTypeParameterDeclaration(node) {
+                for (const param of node.params) {
+                    if (typeof param.name.name === 'string' &&
+                        param.name.name[0] !== 'T') {
+                        context.report({
+                            node: param,
+                            messageId: 'genericStartsWithT',
+                        });
+                    }
+                }
+            },
+        };
+    },
+    name: 'generic-starts-with-t',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce TypeScript generic types to start with T',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            genericStartsWithT: 'Generic type parameter should start with T.',
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=generic-starts-with-t.js.map

package/lib/rules/no-async-array-filter.d.ts

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

package/lib/rules/no-async-array-filter.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAsyncArrayFilter = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.noAsyncArrayFilter = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'filter' &&
+                    node.arguments.length > 0) {
+                    const callback = node.arguments[0];
+                    if ((callback.type === 'FunctionExpression' ||
+                        callback.type === 'ArrowFunctionExpression') &&
+                        callback.async === true) {
+                        context.report({
+                            node: callback,
+                            messageId: 'unexpected',
+                        });
+                    }
+                }
+            },
+        };
+    },
+    name: 'no-async-array-filter',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow async callbacks for Array.filter',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unexpected: 'Async array filter is dangerous as a Promise object will always be truthy. You should move the asynchronous logic elsewhere.',
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=no-async-array-filter.js.map

package/lib/rules/no-async-foreach.d.ts

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

package/lib/rules/no-async-foreach.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAsyncForEach = void 0;
+exports.noAsyncForEach = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.type === 'MemberExpression' &&
+                    callee.property.type === 'Identifier' &&
+                    callee.property.name === 'forEach' &&
+                    node.arguments[0] &&
+                    (node.arguments[0].type === 'ArrowFunctionExpression' ||
+                        node.arguments[0].type === 'FunctionExpression') &&
+                    node.arguments[0].async) {
+                    context.report({
+                        node,
+                        messageId: 'noAsyncForEach',
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow Array.forEach with an async callback function',
+            recommended: 'error',
+        },
+        messages: {
+            noAsyncForEach: 'Do not use async function as callback in Array.forEach. Use a standard for loop for sequential execution or Promise.all for concurrent execution.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+};
+//# sourceMappingURL=no-async-foreach.js.map

package/lib/rules/no-conditional-literals-in-jsx.d.ts

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

package/lib/rules/no-conditional-literals-in-jsx.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noConditionalLiteralsInJsx = void 0;
+/* eslint-disable @blumintinc/blumint/extract-global-constants */
+// import { ASTHelpers } from '../utils/ASTHelpers';
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
+    name: 'no-conditional-literals-in-jsx',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow use of conditional literals in JSX code',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unexpected: 'Conditional expression is a sibling of raw text and must be wrapped in <div> or <span>',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            // Imagine evaluating <div>text {conditional && 'string'}</div>
+            JSXExpressionContainer(node) {
+                // We start at the expression {conditional && 'string'}
+                if (node.expression.type !== 'LogicalExpression') {
+                    return;
+                }
+                const parentChildren = node.parent && 'children' in node.parent ? node.parent.children : [];
+                // "text" is one of the siblingTextNodes.
+                const siblingTextNodes = parentChildren.filter((n) => {
+                    if (n.type === utils_1.TSESTree.AST_NODE_TYPES.Literal ||
+                        n.type === utils_1.TSESTree.AST_NODE_TYPES.JSXText) {
+                        return !!('value' in n && !!n.value ? `${n.value}`.trim() : false);
+                    }
+                    return false;
+                });
+                // If we were evaluating
+                //   <div>{property} {conditional && 'string'}</div>
+                // Then {property} would be one of the siblingExpressionNodes
+                const siblingExpressionNodes = parentChildren.filter((n) => n.type === 'JSXExpressionContainer' &&
+                    'expression' in n &&
+                    (n.expression.type === 'Identifier' ||
+                        n.expression.type === 'MemberExpression'));
+                // Operands of {conditional && 'string'} -- the conditional and the
+                // literal. We want to make sure we have a text literal, otherwise we'd
+                // trigger this rule on the (safe) {conditional && <div>string</div>}.
+                const expressionOperandTypes = [
+                    node.expression.left.type,
+                    node.expression.right.type,
+                ];
+                if (siblingTextNodes.concat(siblingExpressionNodes).length > 0 &&
+                    expressionOperandTypes.includes(utils_1.TSESTree.AST_NODE_TYPES.Literal)) {
+                    context.report({ node, messageId: 'unexpected' });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-conditional-literals-in-jsx.js.map

package/lib/rules/no-filter-without-return.d.ts

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

package/lib/rules/no-filter-without-return.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFilterWithoutReturn = void 0;
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const createRule_1 = require("../utils/createRule");
+exports.noFilterWithoutReturn = (0, createRule_1.createRule)({
+    create(context) {
+        return {
+            'CallExpression[callee.property.name="filter"]'(node) {
+                const callback = node.arguments[0];
+                if (callback && callback.type === 'ArrowFunctionExpression') {
+                    const { body } = callback;
+                    if (body.type !== 'BlockStatement') {
+                        // If the body is not a block statement, it's a direct return
+                        return;
+                    }
+                    if (!ASTHelpers_1.ASTHelpers.hasReturnStatement(body)) {
+                        context.report({
+                            node,
+                            messageId: 'unexpected',
+                        });
+                    }
+                }
+            },
+        };
+    },
+    name: 'no-filter-without-return',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow Array.filter callbacks without an explicit return (if part of a block statement)',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            unexpected: 'An array filter callback with a block statement must contain a return statement',
+        },
+    },
+    defaultOptions: [],
+});
+//# sourceMappingURL=no-filter-without-return.js.map

package/lib/rules/no-misused-switch-case.d.ts

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

package/lib/rules/no-misused-switch-case.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMisusedSwitchCase = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.noMisusedSwitchCase = (0, createRule_1.createRule)({
+    name: 'no-misused-switch-case',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent misuse of logical OR in switch case statements',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMisusedSwitchCase: 'Avoid using logical OR  in switch case. Use cascading cases instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            SwitchStatement(node) {
+                for (const switchCase of node.cases) {
+                    if (switchCase.test?.type === 'LogicalExpression' &&
+                        switchCase.test.operator === '||') {
+                        context.report({
+                            node: switchCase,
+                            messageId: 'noMisusedSwitchCase',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-misused-switch-case.js.map

package/lib/rules/no-unpinned-dependencies.d.ts

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

package/lib/rules/no-unpinned-dependencies.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUnpinnedDependencies = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.noUnpinnedDependencies = (0, createRule_1.createRule)({
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforces pinned dependencies',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            unexpected: "Dependency '{{ propertyName }}' should be pinned to a specific version, but '{{ version }}' was found.",
+        },
+    },
+    defaultOptions: [],
+    name: 'no-unpinned-dependencies',
+    create(context) {
+        return {
+            JSONLiteral(node) {
+                const property = node?.parent;
+                // const property = node.parent;
+                const configSection = node?.parent?.parent?.parent;
+                if (!property || !configSection) {
+                    return;
+                }
+                const configKey = configSection?.key;
+                if (!configKey) {
+                    return;
+                }
+                // Check if we're in the "dependencies" or "devDependencies" section of package.json
+                if (node.type === 'JSONLiteral' &&
+                    property?.type === 'JSONProperty' &&
+                    (configKey.name === 'devDependencies' ||
+                        configKey.value === 'devDependencies' ||
+                        configKey.name === 'dependencies' ||
+                        configKey.value === 'dependencies')) {
+                    // Get the version string
+                    const version = node.value;
+                    const propertyName = property.key.name ||
+                        property.key.value;
+                    // Check if the version string starts with a caret (^) or tilde (~), indicating a non-pinned version
+                    if (typeof version === 'string' &&
+                        (version.includes('^') || version.includes('~'))) {
+                        context.report({
+                            node: node,
+                            messageId: 'unexpected',
+                            data: {
+                                propertyName,
+                                version,
+                            },
+                            fix: function (fixer) {
+                                const fixed = version.replace('^', '').replace('~', '');
+                                return fixer.replaceTextRange(node.range, `"${fixed}"`);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-unpinned-dependencies.js.map

package/lib/rules/no-useless-fragment.d.ts

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

package/lib/rules/no-useless-fragment.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUselessFragment = void 0;
+exports.noUselessFragment = {
+    create(context) {
+        return {
+            JSXFragment(node) {
+                if (node.children.length === 1) {
+                    context.report({
+                        node,
+                        messageId: 'noUselessFragment',
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+                            const openingFragment = sourceCode.getFirstToken(node);
+                            const closingFragment = sourceCode.getLastToken(node);
+                            return [
+                                fixer.removeRange([
+                                    openingFragment.range[0],
+                                    openingFragment.range[0] + 2,
+                                ]),
+                                fixer.removeRange([
+                                    closingFragment.range[0] - 3,
+                                    closingFragment.range[0],
+                                ]),
+                            ];
+                        },
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prevent unnecessary use of React fragments',
+            recommended: 'warn',
+        },
+        messages: {
+            noUselessFragment: 'React fragment is unnecessary when wrapping a single child',
+        },
+        schema: [],
+        fixable: 'code',
+    },
+    defaultOptions: [],
+};
+//# sourceMappingURL=no-useless-fragment.js.map

package/lib/rules/prefer-fragment-shorthand.d.ts

@@ -0,0 +1,3 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const preferFragmentShorthand: TSESLint.RuleModule<'preferShorthand', [
+]>;

package/lib/rules/prefer-fragment-shorthand.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferFragmentShorthand = void 0;
+exports.preferFragmentShorthand = {
+    create(context) {
+        return {
+            JSXElement(node) {
+                const openingElement = node.openingElement;
+                if (openingElement.name.type === 'JSXMemberExpression' &&
+                    openingElement.name.object.type === 'JSXIdentifier' &&
+                    openingElement.name.object.name === 'React' &&
+                    openingElement.name.property.type === 'JSXIdentifier' &&
+                    openingElement.name.property.name === 'Fragment') {
+                    context.report({
+                        node,
+                        messageId: 'preferShorthand',
+                        fix: (fixer) => [
+                            fixer.replaceTextRange(openingElement.range, '<>'),
+                            fixer.replaceTextRange(node.closingElement.range, '</>'),
+                        ],
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer <> shorthand for <React.Fragment>',
+            recommended: 'warn',
+        },
+        messages: {
+            preferShorthand: 'Use <> shorthand for <React.Fragment>, unless a key is required for an iterator',
+        },
+        schema: [],
+        fixable: 'code',
+    },
+    defaultOptions: [],
+};
+//# sourceMappingURL=prefer-fragment-shorthand.js.map

package/lib/rules/prefer-type-over-interface.d.ts

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

package/lib/rules/prefer-type-over-interface.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferTypeOverInterface = void 0;
+const createRule_1 = require("../utils/createRule");
+exports.preferTypeOverInterface = (0, createRule_1.createRule)({
+    name: 'prefer-type-over-interface',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer using type alias over interface',
+            recommended: 'warn',
+        },
+        schema: [],
+        messages: {
+            preferType: 'Prefer using type alias over interface.',
+        },
+        fixable: 'code',
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            TSInterfaceDeclaration(node) {
+                context.report({
+                    node,
+                    messageId: 'preferType',
+                    fix(fixer) {
+                        const sourceCode = context.getSourceCode();
+                        const openingBrace = sourceCode.getTokenAfter(node.id, {
+                            filter: (token) => token.value === '{',
+                        });
+                        const fixes = [
+                            fixer.replaceTextRange([node.range[0], node.id.range[1]], `type ${node.id.name} =`),
+                        ];
+                        if (node.extends && node.extends.length > 0 && openingBrace) {
+                            const extendsKeyword = sourceCode.getFirstTokenBetween(node.id, openingBrace, { filter: (token) => token.value === 'extends' });
+                            fixes.push(fixer.remove(extendsKeyword), fixer.insertTextBefore(openingBrace, '& '));
+                        }
+                        return fixes;
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-type-over-interface.js.map

package/lib/rules/require-memo.d.ts

@@ -0,0 +1,6 @@
+import { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export type NodeWithParent = TSESTree.Node & {
+    parent: NodeWithParent;
+};
+export type ComponentNode = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration;
+export declare const requireMemo: TSESLint.RuleModule<'requireMemo', []>;