@blumintinc/eslint-plugin-blumint 0.1.23 → 1.0.2

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

@@ -1,61 +0,0 @@
-"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.js

@@ -1,41 +0,0 @@
-"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.js

@@ -1,35 +0,0 @@
-"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.js

@@ -1,65 +0,0 @@
-"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.js

@@ -1,46 +0,0 @@
-"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.js

@@ -1,40 +0,0 @@
-"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.js

@@ -1,45 +0,0 @@
-"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.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireMemo = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const ASTHelpers_1 = require("../utils/ASTHelpers");
-const isComponentExplicitlyUnmemoized = (componentName) => componentName.toLowerCase().includes('unmemoized');
-function isFunction(node) {
-    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
-}
-function isHigherOrderFunctionReturningJSX(node) {
-    if (isFunction(node)) {
-        // Check if function takes another function as an argument
-        const hasFunctionParam = 'params' in node && node.params.some(isFunction);
-        if (node.body && node.body.type === 'BlockStatement') {
-            for (const statement of node.body.body) {
-                if (statement.type === 'ReturnStatement' && statement.argument) {
-                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument);
-                    const returnsFunction = isFunction(statement.argument);
-                    return (hasFunctionParam || returnsFunction) && returnsJSX;
-                }
-            }
-        }
-    }
-    return false;
-}
-const isUnmemoizedArrowFunction = (parentNode) => {
-    return (parentNode.type === 'VariableDeclarator' &&
-        parentNode.id.type === 'Identifier' &&
-        !isComponentExplicitlyUnmemoized(parentNode.id.name));
-};
-const isUnmemoizedFunctionComponent = (parentNode, node) => {
-    return (node.type === 'FunctionDeclaration' &&
-        parentNode.type === 'Program' &&
-        node.id &&
-        !isComponentExplicitlyUnmemoized(node.id.name));
-};
-const isUnmemoizedExportedFunctionComponent = (parentNode, node) => {
-    return (node.type === 'FunctionDeclaration' &&
-        parentNode.type === 'ExportNamedDeclaration' &&
-        node.id &&
-        !isComponentExplicitlyUnmemoized(node.id.name));
-};
-function checkFunction(context, node) {
-    const fileName = context.getFilename();
-    if (!fileName.endsWith('.tsx')) {
-        return;
-    }
-    if (isHigherOrderFunctionReturningJSX(node)) {
-        return;
-    }
-    const parentNode = node.parent;
-    if (node.parent.type === 'CallExpression') {
-        return;
-    }
-    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body) && ASTHelpers_1.ASTHelpers.hasParameters(node)) {
-        const results = [
-            isUnmemoizedArrowFunction,
-            isUnmemoizedFunctionComponent,
-            isUnmemoizedExportedFunctionComponent,
-        ].map((fn) => fn(parentNode, node));
-        if (results.some((result) => !!result)) {
-            context.report({
-                node,
-                messageId: 'requireMemo',
-                fix: results[2] || results[1]
-                    ? function fix(fixer) {
-                        const sourceCode = context.getSourceCode();
-                        let importFix = null;
-                        // Search for React import statement
-                        const importDeclarations = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');
-                        const reactImport = importDeclarations.find((importDeclaration) => importDeclaration.source.value === 'react');
-                        if (reactImport) {
-                            // Check if memo is already imported
-                            if (!reactImport.specifiers.some((specifier) => specifier.local.name === 'memo')) {
-                                // Add memo to existing import statement
-                                const lastSpecifier = reactImport.specifiers[reactImport.specifiers.length - 1];
-                                importFix = fixer.insertTextAfter(lastSpecifier, ', memo');
-                            }
-                        }
-                        else {
-                            // Add new import statement for memo
-                            const importStatement = "import { memo } from 'react';\n";
-                            importFix = fixer.insertTextBeforeRange([sourceCode.ast.range[0], sourceCode.ast.range[0]], importStatement);
-                        }
-                        const functionKeywordRange = [
-                            node.range[0],
-                            node.range[0] + 'function'.length,
-                        ];
-                        const functionKeywordReplacement = `const ${node.id.name} = memo(`;
-                        // Step 3: Rename function
-                        const functionNameReplacement = `function ${node.id.name}Unmemoized`;
-                        const fixes = [
-                            fixer.replaceTextRange(functionKeywordRange, functionKeywordReplacement),
-                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ')'),
-                            fixer.replaceTextRange([node.id.range[0] - 1, node.id.range[1]], functionNameReplacement),
-                        ];
-                        if (importFix) {
-                            fixes.push(importFix);
-                        }
-                        return fixes;
-                    }
-                    : undefined,
-            });
-        }
-    }
-}
-exports.requireMemo = {
-    create: (context) => ({
-        ArrowFunctionExpression(node) {
-            checkFunction(context, node);
-        },
-        FunctionDeclaration(node) {
-            checkFunction(context, node);
-        },
-        FunctionExpression(node) {
-            checkFunction(context, node);
-        },
-    }),
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'React components must be memoized',
-            recommended: 'error',
-        },
-        messages: {
-            requireMemo: 'Component definition not wrapped in React.memo()',
-        },
-        schema: [],
-        fixable: 'code',
-    },
-    defaultOptions: [],
-};
-//# sourceMappingURL=require-memo.js.map