eslint-plugin-th-rules 2.7.0 → 2.8.0

package/dist/rules/schemas-in-schemas-file.js

@@ -0,0 +1,141 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export default ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/schemas-in-schemas-file.md')({
+    name: 'schemas-in-schemas-file',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require Zod schema declarations to be placed in a .schemas.ts file.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowedSuffixes: {
+                        type: 'array',
+                        items: { type: 'string', minLength: 1 },
+                        minItems: 1,
+                    },
+                    onlyWhenAssigned: { type: 'boolean' },
+                    allowInTests: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            moveSchema: 'Zod schemas must be defined in a dedicated schemas file ({{suffixes}}).',
+        },
+    },
+    defaultOptions: [
+        {
+            allowedSuffixes: ['.schemas.ts'],
+            onlyWhenAssigned: false,
+            allowInTests: false,
+        },
+    ],
+    create(context, [options]) {
+        const allowedSuffixes = options.allowedSuffixes ?? ['.schemas.ts'];
+        const onlyWhenAssigned = Boolean(options.onlyWhenAssigned);
+        const allowInTests = Boolean(options.allowInTests);
+        const zodIdentifiers = new Set();
+        function filenameAllowed(filename) {
+            if (!filename || filename === '<input>') {
+                return false;
+            }
+            if (allowInTests
+                && /\.(test|spec)\.[jt]sx?$/.test(filename)) {
+                return true;
+            }
+            return allowedSuffixes.some(suffix => filename.endsWith(suffix));
+        }
+        function isZodModuleImport(node) {
+            return (node.source.type === 'Literal'
+                && node.source.value === 'zod');
+        }
+        function collectZodIdentifiersFromImport(node) {
+            if (!isZodModuleImport(node)) {
+                return;
+            }
+            for (const spec of node.specifiers) {
+                if (spec.type === 'ImportSpecifier'
+                    && spec.imported.type === 'Identifier'
+                    && spec.imported.name === 'z'
+                    && spec.local.type === 'Identifier') {
+                    zodIdentifiers.add(spec.local.name);
+                }
+                if (spec.type === 'ImportNamespaceSpecifier'
+                    && spec.local.type === 'Identifier') {
+                    zodIdentifiers.add(spec.local.name);
+                }
+            }
+        }
+        function isZodBuilderCall(node) {
+            const { callee } = node;
+            if (callee.type !== 'MemberExpression'
+                || callee.computed) {
+                return false;
+            }
+            const { object } = callee;
+            const { property } = callee;
+            return (object.type === 'Identifier'
+                && zodIdentifiers.has(object.name)
+                && property.type === 'Identifier');
+        }
+        function isZodChainedBuilderCall(node) {
+            const { callee } = node;
+            if (callee.type !== 'MemberExpression'
+                || callee.computed) {
+                return false;
+            }
+            let current = callee.object;
+            while (current.type === 'MemberExpression'
+                && !current.computed) {
+                current = current.object;
+            }
+            return (current.type === 'Identifier'
+                && zodIdentifiers.has(current.name));
+        }
+        function getAssignmentTargetName(callNode) {
+            const { parent } = callNode;
+            if (parent?.type === 'VariableDeclarator'
+                && parent.id.type === 'Identifier') {
+                return parent.id.name;
+            }
+            if (parent?.type === 'AssignmentExpression'
+                && parent.left.type === 'Identifier') {
+                return parent.left.name;
+            }
+            return null;
+        }
+        function report(node) {
+            const filename = context.getFilename();
+            if (filenameAllowed(filename)) {
+                return;
+            }
+            const targetName = getAssignmentTargetName(node);
+            if (onlyWhenAssigned && !targetName) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: 'moveSchema',
+                data: {
+                    suffixes: allowedSuffixes.join(' or '),
+                },
+            });
+        }
+        return {
+            ImportDeclaration(node) {
+                collectZodIdentifiersFromImport(node);
+            },
+            CallExpression(node) {
+                if (zodIdentifiers.size === 0) {
+                    return;
+                }
+                if (isZodBuilderCall(node)
+                    || isZodChainedBuilderCall(node)) {
+                    report(node);
+                }
+            },
+        };
+    },
+});

package/dist/rules/top-level-functions.d.ts

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

package/dist/rules/top-level-functions.js

@@ -0,0 +1,153 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export default ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/top-level-functions.md')({
+    name: 'top-level-functions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require all top-level functions to be named regular functions.',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            arrow: 'Top-level arrow functions must be named regular functions.',
+            funcExpr: 'Top-level function expressions must be named regular functions.',
+            anonDecl: 'Top-level anonymous function declarations must be named.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        //
+        // Helpers
+        //
+        function buildArrowFunctionReplacement(functionName, arrow, isExport) {
+            const asyncKeyword = arrow.async ? 'async ' : '';
+            const exportKeyword = isExport ? 'export ' : '';
+            const parametersText = arrow.params
+                .map(parameter => sourceCode.getText(parameter))
+                .join(', ');
+            let bodyText;
+            if (arrow.body.type === 'BlockStatement') {
+                bodyText = sourceCode.getText(arrow.body);
+            }
+            else {
+                // Expression → convert to return
+                const expressionText = sourceCode.getText(arrow.body);
+                bodyText = `{ return ${expressionText}; }`;
+            }
+            return `${exportKeyword}${asyncKeyword}function ${functionName}(${parametersText}) ${bodyText}`;
+        }
+        function buildFunctionExpressionReplacement(functionName, funcExpr, isExport) {
+            const asyncKeyword = funcExpr.async ? 'async ' : '';
+            const exportKeyword = isExport ? 'export ' : '';
+            const parametersText = funcExpr.params
+                .map(parameter => sourceCode.getText(parameter))
+                .join(', ');
+            const bodyText = sourceCode.getText(funcExpr.body);
+            return `${exportKeyword}${asyncKeyword}function ${functionName}(${parametersText}) ${bodyText}`;
+        }
+        function buildAnonymousFunctionDeclarationReplacement(node, functionName = 'defaultFunction', isExport = false) {
+            const originalText = sourceCode.getText(node);
+            const exportKeyword = isExport ? 'export ' : '';
+            const asyncFunctionRegex = /^\s*async\s+function\s*\(/;
+            const functionRegex = /^\s*function\s*\(/;
+            let replaced = originalText;
+            if (asyncFunctionRegex.test(replaced)) {
+                replaced = replaced.replace(asyncFunctionRegex, `async function ${functionName}(`);
+            }
+            else {
+                replaced = replaced.replace(functionRegex, `function ${functionName}(`);
+            }
+            if (isExport && !replaced.trimStart().startsWith('export')) {
+                replaced = `${exportKeyword}${replaced}`;
+            }
+            return replaced;
+        }
+        //
+        // Utility
+        //
+        function isTopLevel(node) {
+            const { parent } = node;
+            return (parent?.type === 'Program'
+                || parent?.type === 'ExportNamedDeclaration'
+                || parent?.type === 'ExportDefaultDeclaration');
+        }
+        function isExportContext(node) {
+            const p = node.parent;
+            return (p?.type === 'ExportNamedDeclaration'
+                || p?.type === 'ExportDefaultDeclaration');
+        }
+        //
+        // Rule
+        //
+        return {
+            VariableDeclarator(node) {
+                const declParent = node.parent;
+                const grandParent = declParent?.parent;
+                if (!grandParent) {
+                    return;
+                }
+                const topLevel = grandParent.type === 'Program'
+                    || grandParent.type === 'ExportNamedDeclaration'
+                    || grandParent.type === 'ExportDefaultDeclaration';
+                if (!topLevel) {
+                    return;
+                }
+                const isExport = grandParent.type === 'ExportNamedDeclaration'
+                    || grandParent.type === 'ExportDefaultDeclaration';
+                if (!node.init) {
+                    return;
+                }
+                const functionName = node.id.type === 'Identifier' ? node.id.name : null;
+                if (!functionName) {
+                    return;
+                }
+                //
+                // Arrow functions
+                //
+                if (node.init.type === 'ArrowFunctionExpression') {
+                    const arrowFunc = node.init;
+                    context.report({
+                        node: arrowFunc,
+                        messageId: 'arrow',
+                        fix(fixer) {
+                            const replacement = buildArrowFunctionReplacement(functionName, arrowFunc, isExport);
+                            return fixer.replaceText(isExport ? grandParent : declParent, replacement);
+                        },
+                    });
+                }
+                //
+                // Function expressions
+                //
+                if (node.init.type === 'FunctionExpression') {
+                    const funcExpr = node.init;
+                    context.report({
+                        node: funcExpr,
+                        messageId: 'funcExpr',
+                        fix(fixer) {
+                            const replacement = buildFunctionExpressionReplacement(functionName, funcExpr, isExport);
+                            return fixer.replaceText(isExport ? grandParent : declParent, replacement);
+                        },
+                    });
+                }
+            },
+            FunctionDeclaration(node) {
+                if (node.id) {
+                    return;
+                } // Already named
+                if (!isTopLevel(node)) {
+                    return;
+                }
+                const isExport = isExportContext(node);
+                context.report({
+                    node,
+                    messageId: 'anonDecl',
+                    fix(fixer) {
+                        const replacement = buildAnonymousFunctionDeclarationReplacement(node, 'defaultFunction', isExport);
+                        return fixer.replaceText(isExport ? node.parent : node, replacement);
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/types-in-dts.d.ts

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

package/dist/rules/types-in-dts.js

@@ -0,0 +1,76 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export default ESLintUtils.RuleCreator(() => "https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/types-in-dts.md")({
+    name: "types-in-dts",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require TypeScript type declarations (type/interface/enum) to be placed in .d.ts files."
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowEnums: { type: "boolean" },
+                    allowDeclare: { type: "boolean" }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: {
+            moveToDts: "Type declarations must be defined in a .d.ts file."
+        }
+    },
+    defaultOptions: [
+        {
+            allowEnums: false,
+            allowDeclare: false
+        }
+    ],
+    create(context, [options]) {
+        const allowEnums = Boolean(options.allowEnums);
+        const allowDeclare = Boolean(options.allowDeclare);
+        function isDtsFile(filename) {
+            if (!filename || filename === "<input>") {
+                return false;
+            }
+            return filename.endsWith(".d.ts");
+        }
+        function hasDeclareModifier(node) {
+            // `declare type Foo = ...`
+            if ("declare" in node && node.declare === true) {
+                return true;
+            }
+            const modifiers = "modifiers" in node && Array.isArray(node.modifiers)
+                ? node.modifiers
+                : [];
+            return modifiers.some(m => m?.type === "TSDeclareKeyword");
+        }
+        function reportIfNotDts(node) {
+            const filename = context.getFilename();
+            if (isDtsFile(filename)) {
+                return;
+            }
+            if (allowDeclare && hasDeclareModifier(node)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "moveToDts"
+            });
+        }
+        return {
+            TSTypeAliasDeclaration(node) {
+                reportIfNotDts(node);
+            },
+            TSInterfaceDeclaration(node) {
+                reportIfNotDts(node);
+            },
+            TSEnumDeclaration(node) {
+                if (allowEnums) {
+                    return;
+                }
+                reportIfNotDts(node);
+            }
+        };
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-th-rules",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",
@@ -8,24 +8,29 @@
     "eslint-plugin"
   ],
   "author": "Tomer Horowitz",
-  "main": "./src/index.js",
-  "exports": "./src/index.js",
+  "type": "module",
+  "exports": "./dist/index.js",
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
-    "lint": "npm-run-all \"lint:*\"",
-    "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
-    "lint:js": "eslint .",
+    "build": "tsc",
     "update:eslint-docs": "eslint-doc-generator --config-emoji \"recommended,✅\" --config-emoji \"recommended-react,⚛️\" --config-emoji \"recommended-typescript,🟦\""
   },
   "dependencies": {
-    "@babel/eslint-parser": "^7.28.5",
+    "@babel/eslint-parser": "^7.28.6",
     "@eslint/eslintrc": "^3.3.3",
     "eslint-config-jsdoc": "^15.4.0",
     "eslint-config-xo": "^0.49.0",
     "eslint-config-xo-react": "^0.29.0",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^61.5.0",
+    "eslint-plugin-jsdoc": "^62.0.0",
     "eslint-plugin-lodash": "^8.0.0",
-    "eslint-plugin-n": "^17.23.1",
+    "eslint-plugin-n": "^17.23.2",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-native": "^5.0.0",
@@ -33,7 +38,6 @@
     "eslint-plugin-sonarjs": "^3.0.5",
     "eslint-plugin-unicorn": "^62.0.0",
     "globals": "^17.0.0",
-    "jest": "^30.2.0",
     "lodash": "^4.17.21",
     "requireindex": "^1.2.0"
   },
@@ -48,20 +52,27 @@
     "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/eslint-plugin-security": "^3.0.0",
     "@types/eslint__js": "^9.14.0",
-    "@types/lodash": "^4",
+    "@types/jest": "^30.0.0",
+    "@types/lodash": "^4.17.23",
+    "@types/node": "^25.0.9",
     "@types/requireindex": "^1.2.4",
     "@types/xo": "^0.39.9",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
     "@typescript-eslint/rule-tester": "^8.53.0",
     "bun-types": "latest",
     "eslint": "^9.39.2",
     "eslint-doc-generator": "^3.0.2",
-    "eslint-plugin-eslint-plugin": "^7.2.0",
+    "eslint-plugin-eslint-plugin": "^7.3.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-th-rules": "2.0.4",
+    "eslint-plugin-th-rules": "2.7.1",
+    "jest": "^30.2.0",
     "mocha": "^11.7.5",
     "npm-run-all": "^4.1.5",
+    "semantic-release": "^25.0.2",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.52.0",
+    "typescript-eslint": "^8.53.0",
     "xo": "^1.2.3"
   },
   "license": "ISC",

package/.github/dependabot.yml

@@ -1,15 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  - package-ecosystem: "npm" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: "docker" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"

package/.github/workflows/codecov.yml

@@ -1,26 +0,0 @@
-name: Codecov
-on:
-  push:
-    branches:
-      - main # or master, or whichever branch you want this to run on
-  merge_group:
-    branches: 
-      - main
-  pull_request:
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write # to be able to publish a GitHub release
-      issues: write # to be able to comment on released issues
-      pull-requests: write # to be able to comment on released pull requests
-      id-token: write # to enable use of OIDC for npm provenance
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

package/.github/workflows/codeql.yml

@@ -1,82 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ "main" ]
-  schedule:
-    - cron: '43 18 * * 5'
-
-jobs:
-  analyze:
-    name: Analyze
-    # Runner size impacts CodeQL analysis time. To learn more, please see:
-    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
-    #   - https://gh.io/supported-runners-and-hardware-resources
-    #   - https://gh.io/using-larger-runners
-    # Consider using larger runners for possible analysis time improvements.
-    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'javascript' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby', 'swift' ]
-        # Use only 'java' to analyze code written in Java, Kotlin or both
-        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-
-    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v3
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines.
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #     echo "Run, Build Application using script"
-    #     ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
-      with:
-        category: "/language:${{matrix.language}}"

package/.github/workflows/dependency-review.yml

@@ -1,20 +0,0 @@
-# Dependency Review Action
-#
-# This Action will scan dependency manifest files that change as part of a Pull Request, surfacing known-vulnerable versions of the packages declared or updated in the PR. Once installed, if the workflow run is marked as required, PRs introducing known-vulnerable packages will be blocked from merging.
-#
-# Source repository: https://github.com/actions/dependency-review-action
-# Public documentation: https://docs.github.com/en/code-security/supply-chain-security/understanding-your-software-supply-chain/about-dependency-review#dependency-review-enforcement
-name: 'Dependency Review'
-on: [pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  dependency-review:
-    runs-on: ubuntu-latest
-    steps:
-      - name: 'Checkout Repository'
-        uses: actions/checkout@v4
-      - name: 'Dependency Review'
-        uses: actions/dependency-review-action@v4

package/.github/workflows/main.yml

@@ -1,43 +0,0 @@
-name: Semantic Versioning
-
-on:
-  push:
-    branches:
-    - main
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      issues: write
-      pull-requests: write
-      id-token: write
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Setup Bun
-      uses: oven-sh/setup-bun@v1
-
-    - name: Setup Node.js environment
-      uses: actions/setup-node@v4
-      with:
-        node-version: "22.x"
-
-    - name: Install Dependencies
-      run: bun install --dev
-
-    - name: Verify ESLint flat configs
-      run: node ./scripts/verify.mjs
-
-    - name: Run Tests
-      run: bun test
-
-    - name: Semantic Release
-      run: bunx semantic-release
-      env:
-        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        GH_TOKEN: ${{ secrets.GH_TOKEN }}
-        GH_REPO: ${{ github.server_url }}/${{ github.repository }}