eslint-plugin-th-rules 2.7.1 → 2.8.0

package/dist/index.js

@@ -0,0 +1,21 @@
+import { rules } from './plugin.js';
+// Public bundles
+import { recommended } from './configs/bundles/recommended.js';
+import { recommendedReact } from './configs/bundles/recommended-react.js';
+import { recommendedTypescript } from './configs/bundles/recommended-typescript.js';
+// Internal layers (named exports only)
+export { coreBase } from './configs/core/base.js';
+export { coreTypescript } from './configs/core/typescript.js';
+export { coreReact } from './configs/core/react.js';
+export { externalsBase } from './configs/externals/base.js';
+export { externalsOpinionated } from './configs/externals/opinionated.js';
+export const configs = {
+    recommended,
+    'recommended-react': recommendedReact,
+    'recommended-typescript': recommendedTypescript,
+};
+export default {
+    rules,
+    configs,
+};
+export { rules } from './plugin.js';

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+export declare const rules: any;
+export declare const plugin: {
+    rules: any;
+};
+export default plugin;

package/dist/plugin.js

@@ -0,0 +1,14 @@
+import { readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const rulesDir = join(__dirname, 'rules');
+const ruleFiles = readdirSync(rulesDir).filter(file => file.endsWith('.js'));
+export const rules = Object.fromEntries(await Promise.all(ruleFiles.map(async (file) => {
+    const ruleName = file.replace('.js', '');
+    const ruleModule = await import(`./rules/${file}`);
+    return [ruleName, ruleModule.default];
+})));
+export const plugin = { rules };
+export default plugin;

package/dist/rules/no-boolean-coercion.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"useIsEmpty" | "useIsNil", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-boolean-coercion.js

@@ -0,0 +1,98 @@
+import { ESLintUtils, } from '@typescript-eslint/utils';
+const createRule = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-boolean-coercion.md');
+export default createRule({
+    name: 'no-boolean-coercion',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow Boolean(value) or !!value. Enforce explicit checks: !_.isNil(value) for scalars and !_.isEmpty(value) for strings, arrays, and objects.',
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            useIsEmpty: 'Boolean coercion is not allowed. Use !_.isEmpty(value) for strings, arrays, and objects.',
+            useIsNil: 'Boolean coercion is not allowed. Use !_.isNil(value) for scalar values.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const { sourceCode } = context;
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services?.program?.getTypeChecker?.();
+        // --------------------------------------------------------------------
+        // Helpers
+        // --------------------------------------------------------------------
+        function isBooleanCall(node) {
+            return (node.type === 'CallExpression'
+                && node.callee.type === 'Identifier'
+                && node.callee.name === 'Boolean'
+                && node.arguments.length === 1);
+        }
+        function isDoubleNegation(node) {
+            return (node.type === 'UnaryExpression'
+                && node.operator === '!'
+                && node.argument.type === 'UnaryExpression'
+                && node.argument.operator === '!');
+        }
+        function isCollectionLikeByTS(node) {
+            if (!checker || !services.esTreeNodeToTSNodeMap) {
+                return false;
+            }
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+            if (!tsNode) {
+                return false;
+            }
+            const type = checker.getTypeAtLocation(tsNode);
+            const typeString = checker.typeToString(type);
+            return (typeString.includes('[]')
+                || typeString === 'string'
+                || typeString === 'object'
+                || typeString.startsWith('Array<')
+                || typeString.startsWith('ReadonlyArray<'));
+        }
+        function isCollectionLikeBySyntax(node) {
+            return (node.type === 'ArrayExpression'
+                || node.type === 'ObjectExpression'
+                || (node.type === 'Literal' && typeof node.value === 'string'));
+        }
+        function report(node, valueNode) {
+            const isCollection = isCollectionLikeBySyntax(valueNode)
+                || isCollectionLikeByTS(valueNode);
+            const suggestedFn = isCollection ? '_.isEmpty' : '_.isNil';
+            const replacement = `!${suggestedFn}(${sourceCode.getText(valueNode)})`;
+            context.report({
+                node,
+                messageId: isCollection ? 'useIsEmpty' : 'useIsNil',
+                suggest: [
+                    {
+                        messageId: isCollection ? 'useIsEmpty' : 'useIsNil',
+                        fix(fixer) {
+                            return fixer.replaceText(node, replacement);
+                        },
+                    },
+                ],
+            });
+        }
+        // --------------------------------------------------------------------
+        // Visitors
+        // --------------------------------------------------------------------
+        return {
+            CallExpression(node) {
+                if (isBooleanCall(node)) {
+                    const arg = node.arguments[0];
+                    if (arg) {
+                        report(node, arg);
+                    }
+                }
+            },
+            UnaryExpression(node) {
+                if (isDoubleNegation(node)) {
+                    const valueNode = node.argument.argument;
+                    if (valueNode) {
+                        report(node, valueNode);
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-comments.d.ts

@@ -0,0 +1,11 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type Options = [
+    {
+        allow?: string[];
+        disallow?: string[];
+    }?
+];
+declare const _default: ESLintUtils.RuleModule<"commentNotAllowed", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-comments.js

@@ -0,0 +1,83 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+const DEFAULT_ALLOWED_PATTERNS = [
+    /todo/i, // Allow TODO (case-insensitive)
+    /warning/i, // Allow WARNING (case-insensitive)
+    /error/i, // Allow ERROR (case-insensitive)
+    /info/i, // Allow INFO (case-insensitive)
+    /^\s*eslint-(disable|enable|env|globals|ignore|directive)/,
+];
+export default ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-comments.md')({
+    name: 'no-comments',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow comments except for specified allowed patterns.',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allow: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Additional patterns to allow in comments.',
+                    },
+                    disallow: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Additional patterns to disallow in comments.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            commentNotAllowed: 'Comment not allowed.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const option = context.options[0] ?? {};
+        const userAllowedPatterns = (option.allow ?? []).map(pattern => new RegExp(pattern));
+        const userDisallowedPatterns = (option.disallow ?? []).map(pattern => new RegExp(pattern));
+        function isCommentAllowed(comment) {
+            const text = comment.value.trim();
+            // Allow JSDoc
+            if (comment.type === 'Block' && comment.value.startsWith('*')) {
+                return true;
+            }
+            for (const pattern of [
+                ...DEFAULT_ALLOWED_PATTERNS,
+                ...userAllowedPatterns,
+            ]) {
+                if (pattern.test(text)) {
+                    return true;
+                }
+            }
+            for (const pattern of userDisallowedPatterns) {
+                if (pattern.test(text)) {
+                    return false;
+                }
+            }
+            return false;
+        }
+        return {
+            Program() {
+                const sourceCode = context.getSourceCode();
+                const comments = sourceCode.getAllComments();
+                for (const comment of comments) {
+                    if (!isCommentAllowed(comment)) {
+                        context.report({
+                            node: comment,
+                            messageId: 'commentNotAllowed',
+                            fix(fixer) {
+                                return fixer.remove(comment);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-default-export.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"unnamed", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-default-export.js

@@ -0,0 +1,61 @@
+import * as path from 'node:path';
+import { ESLintUtils } from '@typescript-eslint/utils';
+export default ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-default-export.md')({
+    name: 'no-default-export',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Convert unnamed default exports to named default exports based on the file name.',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            unnamed: 'Unnamed default export should be named based on the file name.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        function generateExportNameFromFileName(fileName) {
+            // Remove all invalid characters, replace with spaces
+            const cleaned = fileName.replaceAll(/[^a-zA-Z\d]+/g, ' ');
+            // Split into tokens
+            const parts = cleaned
+                .trim()
+                .split(/\s+/g)
+                .filter(Boolean);
+            if (parts.length === 0) {
+                return 'defaultExport';
+            }
+            // Build camelCase
+            const [first, ...rest] = parts;
+            return (first.charAt(0).toLowerCase() + first.slice(1)) + rest
+                .map(p => p.charAt(0).toUpperCase() + p.slice(1))
+                .join('');
+        }
+        return {
+            ExportDefaultDeclaration(node) {
+                // 1. skip `export default Foo`
+                if (node.declaration.type === 'Identifier') {
+                    return;
+                }
+                // 2. skip named function/class: `export default function Foo() {}`
+                if ('id' in node.declaration && node.declaration.id != null) {
+                    return;
+                }
+                const fileName = context.getFilename();
+                const base = path.basename(fileName, path.extname(fileName));
+                const exportName = generateExportNameFromFileName(base);
+                context.report({
+                    node,
+                    messageId: 'unnamed',
+                    fix(fixer) {
+                        const sourceCode = context.getSourceCode();
+                        const declText = sourceCode.getText(node.declaration);
+                        const replacement = `const ${exportName} = ${declText};\nexport default ${exportName};`;
+                        return fixer.replaceText(node, replacement);
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/no-destructuring.d.ts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"tooDeep" | "tooMany" | "tooLong", [{
+    maximumDestructuredVariables: number;
+    maximumLineLength: number;
+}], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-destructuring.js

@@ -0,0 +1,121 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+const MAX_TAB_COUNT = 3;
+export default ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-destructuring.md')({
+    name: 'no-destructuring',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow destructuring that does not meet certain conditions.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    maximumDestructuredVariables: { type: 'integer', minimum: 0 },
+                    maximumLineLength: { type: 'integer', minimum: 0 },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            tooDeep: 'Destructuring at a nesting level above {{max}} is not allowed; found {{actual}} levels of nesting.',
+            tooMany: 'Destructuring of more than {{max}} variables is not allowed.',
+            tooLong: 'Destructuring spanning a line exceeding {{max}} characters is not allowed.',
+        },
+    },
+    defaultOptions: [
+        {
+            maximumDestructuredVariables: 2,
+            maximumLineLength: 100,
+        },
+    ],
+    create(context, [options]) {
+        const MAX_VARIABLES = options.maximumDestructuredVariables ?? 2;
+        const MAX_LINE_LENGTH = options.maximumLineLength ?? 100;
+        const sourceCode = context.getSourceCode();
+        function reportIfNeeded(patternNode, reportNode = patternNode) {
+            if (patternNode?.type !== 'ObjectPattern'
+                || !patternNode.loc) {
+                return;
+            }
+            const startLine = patternNode.loc.start.line;
+            const endLine = patternNode.loc.end.line;
+            const lineText = sourceCode.lines[startLine - 1] ?? '';
+            const indentCount = lineText.search(/\S|$/);
+            const propertyCount = (patternNode).properties
+                ?.length ?? 0;
+            let maxSpannedLineLength = 0;
+            for (let i = startLine; i <= endLine; i++) {
+                const t = sourceCode.lines[i - 1] ?? '';
+                if (t.length > maxSpannedLineLength) {
+                    maxSpannedLineLength = t.length;
+                }
+            }
+            if (indentCount > MAX_TAB_COUNT) {
+                context.report({
+                    node: reportNode,
+                    messageId: 'tooDeep',
+                    data: {
+                        max: MAX_TAB_COUNT,
+                        actual: indentCount,
+                    },
+                });
+            }
+            if (propertyCount > MAX_VARIABLES) {
+                context.report({
+                    node: reportNode,
+                    messageId: 'tooMany',
+                    data: {
+                        max: MAX_VARIABLES,
+                    },
+                });
+            }
+            if (maxSpannedLineLength > MAX_LINE_LENGTH) {
+                context.report({
+                    node: reportNode,
+                    messageId: 'tooLong',
+                    data: {
+                        max: MAX_LINE_LENGTH,
+                    },
+                });
+            }
+        }
+        function checkParameters(parameters) {
+            for (const p of parameters || []) {
+                if (!p) {
+                    continue;
+                }
+                // (...args = {}) pattern
+                if (p.type === 'AssignmentPattern') {
+                    reportIfNeeded(p.left, p);
+                    continue;
+                }
+                reportIfNeeded(p, p);
+            }
+        }
+        return {
+            VariableDeclarator(node) {
+                reportIfNeeded(node.id, node);
+            },
+            FunctionDeclaration(node) {
+                checkParameters(node.params);
+            },
+            FunctionExpression(node) {
+                checkParameters(node.params);
+            },
+            ArrowFunctionExpression(node) {
+                checkParameters(node.params);
+            },
+            MethodDefinition(node) {
+                if (node.value?.params) {
+                    checkParameters(node.value.params);
+                }
+            },
+            TSDeclareFunction(node) {
+                if (node.params) {
+                    checkParameters(node.params);
+                }
+            },
+        };
+    },
+});

package/dist/rules/prefer-is-empty.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+declare const _default: ESLintUtils.RuleModule<"useIsEmpty", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/prefer-is-empty.js

@@ -0,0 +1,101 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export default ESLintUtils.RuleCreator(() => "https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/prefer-is-empty.md")({
+    name: "prefer-is-empty",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require _.isEmpty instead of length comparisons."
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            useIsEmpty: "Use _.isEmpty({{collection}}) instead of checking {{collection}}.length {{operator}} {{value}}."
+        }
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        function isLengthAccess(node) {
+            return (!!node &&
+                node.type === "MemberExpression" &&
+                node.property.type === "Identifier" &&
+                node.property.name === "length" &&
+                node.computed === false);
+        }
+        function isNumericLiteral(node) {
+            return (!!node &&
+                node.type === "Literal" &&
+                typeof node.value === "number");
+        }
+        function report(node, collectionNode, operator, value, isEmptyCheck) {
+            const collectionText = sourceCode.getText(collectionNode.object);
+            const replacement = isEmptyCheck
+                ? `_.isEmpty(${collectionText})`
+                : `!_.isEmpty(${collectionText})`;
+            context.report({
+                node,
+                messageId: "useIsEmpty",
+                data: {
+                    collection: collectionText,
+                    operator,
+                    value
+                },
+                suggest: [
+                    {
+                        messageId: "useIsEmpty",
+                        data: {
+                            collection: collectionText,
+                            operator,
+                            value
+                        },
+                        fix(fixer) {
+                            return fixer.replaceText(node, replacement);
+                        }
+                    }
+                ]
+            });
+        }
+        return {
+            BinaryExpression(node) {
+                const { left, right, operator } = node;
+                //
+                // Case 1: values.length <op> N
+                //
+                if (isLengthAccess(left) && isNumericLiteral(right)) {
+                    const value = right.value;
+                    // EMPTY checks
+                    if ((operator === "===" && value === 0) ||
+                        (operator === "<=" && value === 0) ||
+                        (operator === "<" && value === 1)) {
+                        report(node, left, operator, value, true);
+                        return;
+                    }
+                    // NOT EMPTY checks
+                    if ((operator === ">" && value === 0) ||
+                        (operator === ">=" && value === 1) ||
+                        ((operator === "!=" || operator === "!==") && value === 0)) {
+                        report(node, left, operator, value, false);
+                    }
+                }
+                //
+                // Case 2: N <op> values.length (reverse order)
+                //
+                if (isNumericLiteral(left) && isLengthAccess(right)) {
+                    const value = left.value;
+                    // EMPTY checks
+                    if ((operator === "===" && value === 0) ||
+                        (operator === ">=" && value === 0) ||
+                        (operator === ">" && value === 0)) {
+                        report(node, right, operator, value, true);
+                        return;
+                    }
+                    // NOT EMPTY checks
+                    if ((operator === "<" && value === 1) ||
+                        (operator === "<=" && value === 0)) {
+                        report(node, right, operator, value, false);
+                    }
+                }
+            }
+        };
+    }
+});

package/dist/rules/schemas-in-schemas-file.d.ts

@@ -0,0 +1,9 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"moveSchema", [{
+    allowedSuffixes: string[];
+    onlyWhenAssigned: boolean;
+    allowInTests: boolean;
+}], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;