lint-suite 1.0.4 → 1.0.6

package/index.js

@@ -5,6 +5,8 @@ var angularTemplate = [
   {
     files: ["**/*.html"],
     rules: {
+      "@angular-eslint/template/no-any": "error",
+      "@angular-eslint/template/no-duplicate-attributes": "error",
       "@angular-eslint/template/button-has-type": "error",
       "@angular-eslint/template/no-positive-tabindex": "error",
       "@angular-eslint/template/valid-aria": "error",
@@ -56,8 +58,8 @@ var angular = [
 
 // packages/lint-suite/src/lib/base.ts
 import nx3 from "@nx/eslint-plugin";
-import importPlugin from "eslint-plugin-import";
 import stylistic from "@stylistic/eslint-plugin";
+import importPluginX from "eslint-plugin-import-x";
 var base = [
   ...nx3.configs["flat/base"],
   {
@@ -71,7 +73,7 @@ var base = [
       "**/*.cts",
       "**/*.mts"
     ],
-    ...importPlugin.flatConfigs.recommended
+    ...importPluginX.flatConfigs.recommended
   },
   {
     files: [
@@ -98,8 +100,60 @@ var base = [
       "**/*.mts"
     ],
     rules: {
-      "no-console": "warn",
+      "no-param-reassign": "error",
+      "no-alert": "error",
+      "no-console": ["warn", { allow: ["warn", "error"] }],
+      "no-debugger": "error",
+      eqeqeq: ["error", "always", { null: "ignore" }],
+      curly: ["error", "all"],
+      "prefer-const": ["error", { destructuring: "all" }],
+      "no-var": "error",
+      "object-shorthand": "error",
+      "prefer-arrow-callback": "error",
+      "no-useless-concat": "error",
+      "prefer-template": "error",
+      "no-nested-ternary": "error",
+      "no-return-await": "error",
+      "no-else-return": ["error", { allowElseIf: false }],
+      // Prefer early returns
+      "no-multi-assign": "error",
+      // Disallow chaining assignments
+      radix: "error",
+      // Require radix parameter for parseInt()
+      yoda: "error",
+      // Disallow yoda conditions (`if ("red" === color)`)
+      complexity: ["warn", 10],
+      // Warn if function complexity is high
+      "max-depth": ["warn", 4],
+      // Warn on deeply nested blocks
+      "max-lines-per-function": ["warn", 50],
+      // Warn on long functions
+      "max-params": ["warn", 4],
+      // Warn on functions with many parameters
+      "no-lonely-if": "error",
+      // Disallow if statements as the only statement in an else block
+      "grouped-accessor-pairs": ["error", "getBeforeSet"],
+      // Enforce consistency for getters/setters
       "class-methods-use-this": "error",
+      "no-underscore-dangle": "error",
+      "padding-line-between-statements": [
+        "error",
+        {
+          blankLine: "always",
+          prev: "export",
+          next: ["export", "const"]
+        },
+        {
+          blankLine: "always",
+          prev: "*",
+          next: "return"
+        },
+        {
+          blankLine: "always",
+          prev: "*",
+          next: "if"
+        }
+      ],
       "max-len": [
         "error",
         {
@@ -177,6 +231,8 @@ var base = [
   {
     files: ["**/*.spec.ts", "**/*.test.ts", "**/*.spec.js", "**/*.test.js"],
     rules: {
+      "max-lines-per-function": "off",
+      complexity: ["warn", { max: 1 }],
       "max-lines": [
         "error",
         {
@@ -186,35 +242,6 @@ var base = [
         }
       ]
     }
-  }
-];
-
-// packages/lint-suite/src/lib/typescript.ts
-import nx4 from "@nx/eslint-plugin";
-import importPlugin2 from "eslint-plugin-import";
-var typescript = [
-  // NOTE: Checks for 'prettier' and 'eslint-plugin-prettier'
-  importPlugin2.flatConfigs.typescript,
-  ...nx4.configs["flat/typescript"],
-  {
-    files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
-    rules: {
-      "@typescript-eslint/explicit-member-accessibility": "error",
-      "@typescript-eslint/consistent-type-imports": "error",
-      "@typescript-eslint/explicit-function-return-type": "warn",
-      "@typescript-eslint/no-empty-function": "error"
-    }
-  },
-  {
-    files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
-    languageOptions: {
-      parserOptions: {
-        projectService: true
-      }
-    },
-    rules: {
-      "@typescript-eslint/prefer-readonly": "error"
-    }
   },
   {
     files: ["**/*.action.ts"],
@@ -230,15 +257,17 @@ var typescript = [
   }
 ];
 
+// packages/lint-suite/src/lib/javascript.ts
+import nx4 from "@nx/eslint-plugin";
+var javascript = nx4.configs["flat/javascript"];
+
 // packages/lint-suite/src/lib/jest.ts
 import jestEslint from "eslint-plugin-jest";
 var jest = [
   {
     files: ["**/*.spec.ts", "**/*.test.ts", "**/*.spec.js", "**/*.test.js"],
-    ...jestEslint.configs["flat/recommended"],
+    ...jestEslint.configs["flat/all"],
     rules: {
-      ...jestEslint.configs["flat/recommended"].rules,
-      ...jestEslint.configs["flat/style"].rules,
       "jest/no-done-callback": "off"
     }
   }
@@ -303,6 +332,7 @@ var rxjs = [
     rules: {
       "rxjs/prefer-observer": "error",
       "rxjs/finnish": "warn",
+      "rxjs/no-ignored-subscription": "warn",
       "rxjs/no-ignored-error": "warn",
       "rxjs/no-unsafe-switchmap": "error",
       "rxjs/no-unsafe-takeuntil": "error",
@@ -327,13 +357,370 @@ var storybook = [
   ...storybookEslint.configs["flat/recommended"],
   {
     ignores: ["!.storybook"],
-    files: ["**/*.stories.ts"]
+    files: ["**/*.stories.ts"],
+    rules: {
+      "storybook/no-uninstalled-addons": [
+        "error",
+        { packageJsonLocation: "package.json" }
+      ]
+    }
   }
 ];
 
-// packages/lint-suite/src/lib/javascript.ts
+// packages/lint-suite/src/lib/typescript.ts
 import nx5 from "@nx/eslint-plugin";
-var javascript = [...nx5.configs["flat/javascript"]];
+import { createTypeScriptImportResolver } from "eslint-import-resolver-typescript";
+import importPluginX2 from "eslint-plugin-import-x";
+
+// packages/lint-suite/src/lib/rules/explicit-accessibility.ts
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+var createRule = ESLintUtils.RuleCreator(
+  () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
+);
+var defaultOptions = {
+  defaultAccessibility: "private"
+};
+var getNodeName = (node) => {
+  if (!node) {
+    return "<unknown>";
+  }
+  if ("key" in node && node.key) {
+    if (node.key.type === TSESTree.AST_NODE_TYPES.Identifier) {
+      return node.key.name;
+    }
+    if (node.key.type === TSESTree.AST_NODE_TYPES.PrivateIdentifier) {
+      return `#${node.key.name}`;
+    }
+    return "<computed/complex key>";
+  }
+  if ("kind" in node && node.kind === "constructor") {
+    return "constructor";
+  }
+  if (node.type === TSESTree.AST_NODE_TYPES.TSParameterProperty) {
+    const param = node.parameter;
+    if (param.type === TSESTree.AST_NODE_TYPES.Identifier) {
+      return param.name;
+    }
+    if (param.type === TSESTree.AST_NODE_TYPES.AssignmentPattern) {
+      if (param.left.type === TSESTree.AST_NODE_TYPES.Identifier) {
+        return param.left.name;
+      }
+      return "<destructured parameter>";
+    }
+    if (param.type === TSESTree.AST_NODE_TYPES.RestElement && param.argument.type === TSESTree.AST_NODE_TYPES.Identifier) {
+      return `...${param.argument.name}`;
+    }
+    return "<complex parameter>";
+  }
+  return "<unknown>";
+};
+var explicit_accessibility_default = createRule({
+  name: "explicit-accessibility",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require explicit accessibility modifiers on class members"
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          defaultAccessibility: {
+            type: "string",
+            enum: ["public", "private", "protected"],
+            description: "The accessibility modifier to add if one is missing."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      missingAccessibility: "Class member '{{ name }}' is missing an explicit accessibility modifier (public/private/protected)."
+    }
+  },
+  defaultOptions: [defaultOptions],
+  create(context, [options]) {
+    const { defaultAccessibility } = { ...defaultOptions, ...options };
+    const sourceCode = context.sourceCode;
+    function checkNode(node) {
+      if (node.accessibility) {
+        return;
+      }
+      let reportNode = node;
+      const name = getNodeName(node);
+      if (node.type === TSESTree.AST_NODE_TYPES.MethodDefinition || node.type === TSESTree.AST_NODE_TYPES.PropertyDefinition) {
+        reportNode = node.key;
+      } else {
+        const param = node.parameter;
+        if (param.type === TSESTree.AST_NODE_TYPES.Identifier) {
+          reportNode = param;
+        } else if (param.type === TSESTree.AST_NODE_TYPES.AssignmentPattern && param.left.type === TSESTree.AST_NODE_TYPES.Identifier) {
+          reportNode = param.left;
+        }
+      }
+      context.report({
+        node: reportNode,
+        messageId: "missingAccessibility",
+        data: { name },
+        fix(fixer) {
+          let tokenToInsertBefore = null;
+          let insertText = `${defaultAccessibility} `;
+          if (node.decorators.length > 0) {
+            const lastDecorator = node.decorators[node.decorators.length - 1];
+            tokenToInsertBefore = sourceCode.getTokenAfter(lastDecorator);
+          } else {
+            tokenToInsertBefore = sourceCode.getFirstToken(node);
+          }
+          if (node.type === TSESTree.AST_NODE_TYPES.TSParameterProperty && node.readonly) {
+            const firstToken = sourceCode.getFirstToken(node);
+            if (firstToken?.value === "readonly") {
+              tokenToInsertBefore = firstToken;
+            }
+          }
+          if (!tokenToInsertBefore)
+            return null;
+          const tokenAfterInsertion = sourceCode.getTokenAfter(
+            tokenToInsertBefore,
+            { includeComments: false }
+          );
+          const textBetween = sourceCode.text.slice(
+            tokenToInsertBefore.range[1],
+            tokenAfterInsertion?.range[0]
+          );
+          if (!/^\s/.test(textBetween)) {
+            insertText = ` ${insertText}`;
+          }
+          return fixer.insertTextBefore(tokenToInsertBefore, insertText);
+        }
+      });
+    }
+    return {
+      MethodDefinition(node) {
+        checkNode(node);
+      },
+      PropertyDefinition(node) {
+        checkNode(node);
+      },
+      TSParameterProperty(node) {
+        checkNode(node);
+      }
+    };
+  }
+});
+
+// packages/lint-suite/src/lib/typescript.ts
+var localTypescriptRules = {
+  rules: {
+    "explicit-accessibility": explicit_accessibility_default
+  }
+};
+var typescript = [
+  // NOTE: Checks for 'prettier' and 'eslint-plugin-prettier'
+  importPluginX2.flatConfigs.typescript,
+  ...nx5.configs["flat/typescript"],
+  {
+    files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
+    plugins: { local: localTypescriptRules },
+    rules: {
+      "local/explicit-accessibility": "error",
+      "@typescript-eslint/explicit-member-accessibility": "error",
+      "@typescript-eslint/explicit-function-return-type": "error",
+      "@typescript-eslint/no-empty-function": "error",
+      "@typescript-eslint/no-unused-vars": "error",
+      "@typescript-eslint/no-use-before-define": "error",
+      // A. Eliminating `any` (already covered by strict-type-checked, but explicit for clarity)
+      "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
+      "@typescript-eslint/no-unsafe-argument": "error",
+      // B. Explicit Annotations (partially covered, explicit module boundaries is key)
+      "@typescript-eslint/explicit-module-boundary-types": "error",
+      // Consider enabling if maximum explicitness is desired, even if verbose:
+      // C. Null/Undefined Safety (Requires strictNullChecks)
+      "@typescript-eslint/no-non-null-assertion": "error",
+      // D. Promise Handling (Supplementing plugin:promise/recommended)
+      "@typescript-eslint/no-floating-promises": [
+        "error",
+        { ignoreVoid: true }
+      ],
+      "@typescript-eslint/no-misused-promises": "warn",
+      // Already in recommended-type-checked
+      "@typescript-eslint/promise-function-async": "error",
+      "@typescript-eslint/await-thenable": "error",
+      // Already in recommended-type-checked
+      // E. Best Practices & Potential Errors (Some covered by presets, fine-tuning here)
+      "@typescript-eslint/no-inferrable-types": "warn",
+      // Keep as warn or disable if inference is preferred
+      "@typescript-eslint/no-var-requires": "error",
+      // Use ES modules
+      "@typescript-eslint/require-await": "error",
+      "@typescript-eslint/restrict-template-expressions": [
+        "error",
+        { allowNumber: true, allowBoolean: true }
+      ],
+      // Allow numbers/booleans in templates
+      "@typescript-eslint/restrict-plus-operands": "error",
+      // Enforce consistent types for '+'
+      "@typescript-eslint/prefer-as-const": "error",
+      "@typescript-eslint/no-shadow": "error",
+      "@typescript-eslint/switch-exhaustiveness-check": "error",
+      // Ensure switch on unions is exhaustive
+      "@typescript-eslint/no-unused-expressions": [
+        "error",
+        { allowShortCircuit: true, allowTernary: true }
+      ],
+      "@typescript-eslint/no-useless-constructor": "error",
+      "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
+      // Prefer dot notation where possible
+      // F. Consistency & Style (Some covered by stylistic-type-checked)
+      "@typescript-eslint/consistent-type-assertions": [
+        "error",
+        { assertionStyle: "as", objectLiteralTypeAssertions: "never" }
+      ],
+      "@typescript-eslint/consistent-type-definitions": ["error", "type"],
+      "@typescript-eslint/consistent-type-imports": [
+        "error",
+        { prefer: "type-imports", fixStyle: "separate-type-imports" }
+      ],
+      "@typescript-eslint/naming-convention": [
+        "error",
+        {
+          selector: "objectLiteralProperty",
+          modifiers: ["requiresQuotes"],
+          format: null
+        },
+        {
+          selector: "objectLiteralProperty",
+          format: ["camelCase", "snake_case", "PascalCase"]
+        },
+        {
+          selector: "parameter",
+          format: ["camelCase"],
+          leadingUnderscore: "allow"
+        },
+        { selector: "default", format: ["camelCase"] },
+        { selector: "variable", format: ["camelCase", "UPPER_CASE"] },
+        { selector: "function", format: ["camelCase"] },
+        { selector: "typeLike", format: ["PascalCase"] },
+        {
+          selector: "property",
+          modifiers: ["requiresQuotes"],
+          format: null
+        },
+        {
+          selector: "property",
+          format: ["camelCase", "PascalCase", "snake_case"]
+        }
+      ],
+      "import-x/order": [
+        "error",
+        {
+          groups: [
+            "builtin",
+            "external",
+            "internal",
+            ["parent", "sibling"],
+            "index",
+            "unknown"
+          ],
+          pathGroups: [
+            {
+              pattern: "@angular/**",
+              group: "builtin",
+              position: "before"
+            },
+            {
+              pattern: "@nestjs/**",
+              group: "builtin",
+              position: "before"
+            },
+            {
+              pattern: "@*/shared/**",
+              group: "internal",
+              position: "before"
+            },
+            {
+              pattern: "@*/frontend/**",
+              group: "internal",
+              position: "after"
+            },
+            {
+              pattern: "@*/backend/**",
+              group: "internal",
+              position: "after"
+            }
+          ],
+          pathGroupsExcludedImportTypes: ["@angular/**", "@nestjs/**"],
+          "newlines-between": "always",
+          alphabetize: { order: "asc", caseInsensitive: true }
+        }
+      ],
+      "import-x/no-unresolved": "error",
+      "import-x/no-duplicates": "error",
+      "import-x/prefer-default-export": "off",
+      "import-x/no-useless-path-segments": "error",
+      "import-x/newline-after-import": "error",
+      "import-x/first": "error",
+      "import-x/no-mutable-exports": "error"
+    },
+    settings: {
+      "import-x/resolver-next": [
+        createTypeScriptImportResolver({
+          alwaysTryTypes: true,
+          project: "tsconfig.base.json"
+        })
+      ]
+    }
+  },
+  {
+    files: ["**/*.ts", "**/*.tsx", "**/*.cts", "**/*.mts"],
+    languageOptions: {
+      parserOptions: {
+        projectService: true
+      }
+    },
+    rules: {
+      "@typescript-eslint/prefer-readonly": "error"
+    }
+  },
+  {
+    files: ["**/*.action.ts"],
+    rules: {
+      "@typescript-eslint/no-namespace": "off"
+    }
+  },
+  {
+    files: ["**/*.spec.ts", "**/*.test.ts", "**/*.spec.js", "**/*.test.js"],
+    rules: {
+      "@typescript-eslint/no-empty-function": "off",
+      "@typescript-eslint/no-unbound-method": "off",
+      "@typescript-eslint/consistent-type-assertions": "off"
+    }
+  },
+  {
+    files: ["**/*.stories.ts"],
+    rules: {
+      "@typescript-eslint/consistent-type-assertions": "off",
+      "@typescript-eslint/naming-convention": "off"
+    }
+  }
+];
+
+// packages/lint-suite/src/index.ts
+var recommended = [
+  ...base,
+  ...javascript,
+  ...typescript,
+  ...angular,
+  ...angularTemplate,
+  ...rxjs,
+  ...jest,
+  ...json,
+  ...storybook
+];
 export {
   angular,
   angularTemplate,
@@ -341,6 +728,7 @@ export {
   javascript,
   jest,
   json,
+  recommended,
   rxjs,
   storybook,
   typescript