@open-turo/eslint-config-typescript 15.0.1 → 16.0.0-pr-373.4.1.1

package/.github/workflows/prerelease.yaml

@@ -0,0 +1,24 @@
+name: Prerelease
+
+on:
+  pull_request:
+    types:
+      - opened
+      - labeled
+      - synchronize
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  prerelease:
+    name: Prerelease
+    runs-on: ubuntu-latest
+    if: contains(github.event.pull_request.labels.*.name, 'prerelease')
+    steps:
+      - name: Prerelease
+        id: prerelease
+        uses: open-turo/actions-node/prerelease@v6
+        with:
+          github-token: ${{ secrets.OPEN_TURO_GITHUB_TOKEN }}
+          npm-token: ${{ secrets.OPEN_TURO_NPM_TOKEN }}
+          create-prerelease: true

package/README.md

@@ -19,33 +19,21 @@ Install the package and all of its peer dependencies:
 npx install-peerdeps --dev @open-turo/eslint-config-typescript
 ```
 
-Then in your `.eslintrc` file extend from one of the two configurations included in this package:
+### [`eslint.config.js`](https://eslint.org/docs/latest/use/configure/configuration-files-new) (requires eslint>=v8.23.0)
 
-1. The default, recommended for new Typescript projects
-2. The "legacy", which is used by `eslint-config-react`, to support our existing front-end projects
+```js
+const turoConfig = require("@open-turo/eslint-config-typescript");
 
-### Default config (for new projects)
-
-The default config of this repo is the recommended version for new Typescript projects.
-
-To use this config, just add to your `.eslintrc` the following:
-
-```
-"extends": "@open-turo/eslint-config-typescript"
+module.exports = turoConfig;
 ```
 
-### Legacy config (for some internal front-end projects)
-
-We also provide an alternative `legacy` preset, which is used by `eslint-config-react`, for compatibility with our
-existing front-end projects.
-
-If you want to use this `legacy` configuration, you can import it by instead adding the following to your `.eslintrc`:
+### **[.eslintrc](https://eslint.org/docs/latest/use/configure/configuration-files)** (legacy example)
 
+```jsonc
+{
+  "extends": "@open-turo/eslint-config-typescript/recommended"],
+}
 ```
-"extends": "@open-turo/eslint-config-typescript/legacy"
-```
-
-Simply notice the `/legacy` suffix, which points to the `legacy.js` file in this repository.
 
 ## Development
 

package/docs/breaking-changes/v16.md

@@ -0,0 +1,63 @@
+# Breaking changes in v16
+
+## Minimum Node.js version
+
+The minimum Node.js supported version is now `^20`.
+
+## Removed plugins
+
+The following plugins are getting replaced by [eslint-plugin-perfectionist](https://github.com/azat-io/eslint-plugin-perfectionist):
+
+- [eslint-plugin-simple-import-sort](https://github.com/lydell/eslint-plugin-simple-import-sort)
+- [eslint-plugin-sort-destructure-keys](https://github.com/mthadley/eslint-plugin-sort-destructure-keys)
+- [eslint-plugin-typescript-sort-keys](https://github.com/infctr/eslint-plugin-typescript-sort-keys/tree/master)
+
+If you were reconfiguring some of the rules from these plugins in your eslint config you will have to update them and reference
+the equivalent rule from https://perfectionist.dev/rules.
+
+## Removed legacy preset
+
+The legacy preset is removed, as it only existed for some internal turo projects. Maintaining it to support eslint v9
+was not worth the effort.
+
+## Default flat configuration
+
+The default configuration for this package is now a flat eslint configuration. Read the
+eslint [guide](https://eslint.org/docs/latest/use/configure/migration-guide) for how to update legacy configurations
+to flat configs.
+
+The legacy configuration is still supported. To keep using it, you just have to update the `.eslintrc` file to:
+
+```diff
+{
+--  "extends": "@open-turo/eslint-config-typescript"
+++  "extends": "@open-turo/eslint-config-typescript/recommended"
+}
+```
+
+### Updating to flat configuration
+
+If you wish to update to a flat configuration, you will have to make the following changes (please refer to the above guide
+for all the details).
+
+- Move from `.eslintrc` (or equivalent file) into `eslint.config.js` (or equivalent file).
+- If you have a `.eslintignore` file, replace that into the `ignores` section of the `eslint.config.js` file
+
+A `.eslintignore` file like this:
+
+```
+/lib
+```
+
+Will become a `eslint.config.js` file like this:
+
+```js
+const turoConfig = require("@open-turo/eslint-config-typescript");
+
+module.exports = [
+  ...turoConfig,
+  {
+    ignores: ["/lib"],
+  },
+];
+```

package/eslint.config.mjs

@@ -0,0 +1,23 @@
+import openTuroTypescriptConfig from "./index.mjs";
+import jestPlugin from "eslint-plugin-jest";
+
+export default [
+  ...openTuroTypescriptConfig,
+  {
+    files: ["*.cjs", "*.mjs", "test/**/*.js"],
+    languageOptions: {
+      parserOptions: {
+        projectService: {
+          // This project doesn't use Typescript and a lot of our rules require type checking
+          allowDefaultProject: [
+            "index.mjs",
+            "index.cjs",
+            "eslint.config.mjs",
+            "recommended.cjs",
+            "test/test.spec.js",
+          ],
+        },
+      },
+    },
+  },
+];

package/index.cjs

@@ -0,0 +1,133 @@
+const jestPlugin = require("eslint-plugin-jest");
+const nPlugin = require("eslint-plugin-n");
+const importPlugin = require("eslint-plugin-import");
+const jsonPlugin = require("eslint-plugin-json");
+const eslint = require("@eslint/js");
+const perfectionistPlugin = require("eslint-plugin-perfectionist");
+const prettierPluginRecommended = require("eslint-plugin-prettier/recommended");
+const tseslint = require("typescript-eslint");
+const sonarjsPlugin = require("eslint-plugin-sonarjs");
+const unicornPlugin = require("eslint-plugin-unicorn");
+const tsParser = require("@typescript-eslint/parser");
+
+module.exports = tseslint.config(
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    extends: [
+      eslint.configs.recommended,
+      tseslint.configs.recommendedTypeChecked,
+      importPlugin.flatConfigs.recommended,
+      importPlugin.flatConfigs.typescript,
+      nPlugin.configs["flat/recommended-script"],
+      perfectionistPlugin.configs["recommended-alphabetical"],
+      sonarjsPlugin.configs.recommended,
+      unicornPlugin.configs["flat/recommended"],
+    ],
+    rules: {
+      "import/default": "off",
+      "import/named": "off",
+      "import/namespace": "off",
+      "import/no-default-export": "error",
+      "import/no-extraneous-dependencies": [
+        "error",
+        { devDependencies: ["test/**"] },
+      ],
+      "import/prefer-default-export": "off",
+      "n/no-unpublished-import": [
+        "error",
+        {
+          allowModules: ["@jest/globals", "nock"],
+        },
+      ],
+      "n/no-unsupported-features/es-syntax": "off",
+      "n/no-missing-import": "off",
+      // Noisy rule - we may have helpers/methods that we mark as @deprecated but aren't planning to remove in the near future. This rule also significantly adds to eslint running time, which slows down both local development and CI.
+      "sonarjs/deprecation": "off",
+      // This rule is not helpful in TypeScript files, and in JavaScript we often return different types from functions, so this is not a strictness level we want to enforce.
+      "sonarjs/function-return-type": "off",
+      // We may want to catch errors but not use the error object directly, just trigger error handling fallbacks within the catch block.
+      "sonarjs/no-ignored-exceptions": "off",
+      "sonarjs/no-nested-functions": ["warn", { threshold: 5 }],
+      "sonarjs/no-small-switch": "off",
+      // Overlaps with @typescript-eslint/prefer-nullish-coalescing
+      "sonarjs/prefer-nullish-coalescing": "off",
+      // Overlaps with @typescript-eslint/no-unused-vars
+      "sonarjs/no-unused-vars": "off",
+      // Overlaps with @typescript-eslint/prefer-optional-chain
+      "sonarjs/prefer-optional-chain": "off",
+      // Useful for guarding against prop mutation in React, but too much of a lift as very rarely do we apply readonly/ReadonlyArray<T> to type definitions
+      "sonarjs/prefer-read-only-props": "off",
+      // Noisy rule: if we wanted stricter linting of TODOs, we could use unicorn/expiring-todo-comments
+      "sonarjs/todo-tag": "off",
+      // A useful rule to consider for libraries to better document (and export) type definitions, but noisy in app usages (especially around redux type definitions)
+      "sonarjs/use-type-alias": "off",
+      /**
+       * {@link https://typescript-eslint.io/rules/consistent-type-imports | TypeScript ESLint: consistent-type-imports docs}
+       */
+      "@typescript-eslint/consistent-type-imports": [
+        "error",
+        {
+          disallowTypeAnnotations: true,
+          fixStyle: "inline-type-imports",
+          prefer: "type-imports",
+        },
+      ],
+      /** We do not need to force people to wrap `void`-return implicit arrow returns with braces just for a lint rule. TypeScript alone covers functionality, by the return type being `void`. */
+      "@typescript-eslint/no-confusing-void-expression": "off",
+      /** Included as part of `strict-type-checked`, but nothing we want to enforce. */
+      "@typescript-eslint/no-deprecated": "off",
+      /** Prefers `import type {}` syntax over `import { type }` if all imports are type-only */
+      "@typescript-eslint/no-import-type-side-effects": "error",
+      /** A relatively stylistic rule, downgraded to "off" to limit breaking changes in the update that includes `strict-type-checked`. */
+      "@typescript-eslint/no-unnecessary-boolean-literal-compare": "off",
+      /** This rule can help us identify syntax that is more defensive than the types suggest. Unfortunately, it may be protecting us from runtime errors where the type definitions are incorrect. As such, it is turned "off", as even "warn" auto-fixes source code. */
+      "@typescript-eslint/no-unnecessary-condition": "off",
+      /** There is readability benefit to passing in type arguments that match defaults. If defaults change, we may prefer the manual inspection of all the types changed, too. */
+      "@typescript-eslint/no-unnecessary-type-arguments": "off",
+      /** Errors on generic type parameters that are only used once, even though that helps with return type inference. */
+      "@typescript-eslint/no-unnecessary-type-parameters": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          // Allow to name unused vars with _
+          argsIgnorePattern: "^_",
+        },
+      ],
+      "@typescript-eslint/prefer-ts-expect-error": "error",
+      "@typescript-eslint/unbound-method": "error",
+    },
+  },
+  prettierPluginRecommended,
+  jsonPlugin.configs["recommended"],
+  {
+    files: ["test/**"],
+    plugins: { jest: jestPlugin },
+    languageOptions: {
+      globals: jestPlugin.environments.globals.globals,
+    },
+    extends: [jestPlugin.configs["flat/recommended"]],
+    rules: {
+      ...jestPlugin.configs["flat/recommended"].rules,
+      // this turns the original rule off *only* for test files, for jestPlugin compatibility
+      "@typescript-eslint/unbound-method": "off",
+      "jest/no-jest-import": "off",
+      "jest/unbound-method": "error",
+    },
+  },
+  {
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: __dirname,
+      },
+    },
+    settings: {
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true,
+        },
+      },
+    },
+  },
+);

package/index.mjs

@@ -0,0 +1,133 @@
+import jestPlugin from "eslint-plugin-jest";
+import nPlugin from "eslint-plugin-n";
+import importPlugin from "eslint-plugin-import";
+import jsonPlugin from "eslint-plugin-json";
+import eslint from "@eslint/js";
+import perfectionistPlugin from "eslint-plugin-perfectionist";
+import prettierPluginRecommended from "eslint-plugin-prettier/recommended";
+import tseslint from "typescript-eslint";
+import sonarjsPlugin from "eslint-plugin-sonarjs";
+import unicornPlugin from "eslint-plugin-unicorn";
+import tsParser from "@typescript-eslint/parser";
+
+export default tseslint.config(
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    extends: [
+      eslint.configs.recommended,
+      tseslint.configs.recommendedTypeChecked,
+      importPlugin.flatConfigs.recommended,
+      importPlugin.flatConfigs.typescript,
+      nPlugin.configs["flat/recommended-script"],
+      perfectionistPlugin.configs["recommended-alphabetical"],
+      sonarjsPlugin.configs.recommended,
+      unicornPlugin.configs["flat/recommended"],
+    ],
+    rules: {
+      "import/default": "off",
+      "import/named": "off",
+      "import/namespace": "off",
+      "import/no-default-export": "error",
+      "import/no-extraneous-dependencies": [
+        "error",
+        { devDependencies: ["test/**"] },
+      ],
+      "import/prefer-default-export": "off",
+      "n/no-unpublished-import": [
+        "error",
+        {
+          allowModules: ["@jest/globals", "nock"],
+        },
+      ],
+      "n/no-unsupported-features/es-syntax": "off",
+      "n/no-missing-import": "off",
+      // Noisy rule - we may have helpers/methods that we mark as @deprecated but aren't planning to remove in the near future. This rule also significantly adds to eslint running time, which slows down both local development and CI.
+      "sonarjs/deprecation": "off",
+      // This rule is not helpful in TypeScript files, and in JavaScript we often return different types from functions, so this is not a strictness level we want to enforce.
+      "sonarjs/function-return-type": "off",
+      // We may want to catch errors but not use the error object directly, just trigger error handling fallbacks within the catch block.
+      "sonarjs/no-ignored-exceptions": "off",
+      "sonarjs/no-nested-functions": ["warn", { threshold: 5 }],
+      "sonarjs/no-small-switch": "off",
+      // Overlaps with @typescript-eslint/prefer-nullish-coalescing
+      "sonarjs/prefer-nullish-coalescing": "off",
+      // Overlaps with @typescript-eslint/no-unused-vars
+      "sonarjs/no-unused-vars": "off",
+      // Overlaps with @typescript-eslint/prefer-optional-chain
+      "sonarjs/prefer-optional-chain": "off",
+      // Useful for guarding against prop mutation in React, but too much of a lift as very rarely do we apply readonly/ReadonlyArray<T> to type definitions
+      "sonarjs/prefer-read-only-props": "off",
+      // Noisy rule: if we wanted stricter linting of TODOs, we could use unicorn/expiring-todo-comments
+      "sonarjs/todo-tag": "off",
+      // A useful rule to consider for libraries to better document (and export) type definitions, but noisy in app usages (especially around redux type definitions)
+      "sonarjs/use-type-alias": "off",
+      /**
+       * {@link https://typescript-eslint.io/rules/consistent-type-imports | TypeScript ESLint: consistent-type-imports docs}
+       */
+      "@typescript-eslint/consistent-type-imports": [
+        "error",
+        {
+          disallowTypeAnnotations: true,
+          fixStyle: "inline-type-imports",
+          prefer: "type-imports",
+        },
+      ],
+      /** We do not need to force people to wrap `void`-return implicit arrow returns with braces just for a lint rule. TypeScript alone covers functionality, by the return type being `void`. */
+      "@typescript-eslint/no-confusing-void-expression": "off",
+      /** Included as part of `strict-type-checked`, but nothing we want to enforce. */
+      "@typescript-eslint/no-deprecated": "off",
+      /** Prefers `import type {}` syntax over `import { type }` if all imports are type-only */
+      "@typescript-eslint/no-import-type-side-effects": "error",
+      /** A relatively stylistic rule, downgraded to "off" to limit breaking changes in the update that includes `strict-type-checked`. */
+      "@typescript-eslint/no-unnecessary-boolean-literal-compare": "off",
+      /** This rule can help us identify syntax that is more defensive than the types suggest. Unfortunately, it may be protecting us from runtime errors where the type definitions are incorrect. As such, it is turned "off", as even "warn" auto-fixes source code. */
+      "@typescript-eslint/no-unnecessary-condition": "off",
+      /** There is readability benefit to passing in type arguments that match defaults. If defaults change, we may prefer the manual inspection of all the types changed, too. */
+      "@typescript-eslint/no-unnecessary-type-arguments": "off",
+      /** Errors on generic type parameters that are only used once, even though that helps with return type inference. */
+      "@typescript-eslint/no-unnecessary-type-parameters": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          // Allow to name unused vars with _
+          argsIgnorePattern: "^_",
+        },
+      ],
+      "@typescript-eslint/prefer-ts-expect-error": "error",
+      "@typescript-eslint/unbound-method": "error",
+    },
+  },
+  prettierPluginRecommended,
+  jsonPlugin.configs["recommended"],
+  {
+    files: ["test/**"],
+    plugins: { jest: jestPlugin },
+    languageOptions: {
+      globals: jestPlugin.environments.globals.globals,
+    },
+    extends: [jestPlugin.configs["flat/recommended"]],
+    rules: {
+      ...jestPlugin.configs["flat/recommended"].rules,
+      // this turns the original rule off *only* for test files, for jestPlugin compatibility
+      "@typescript-eslint/unbound-method": "off",
+      "jest/no-jest-import": "off",
+      "jest/unbound-method": "error",
+    },
+  },
+  {
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    settings: {
+      "import/resolver": {
+        typescript: {
+          alwaysTryTypes: true,
+        },
+      },
+    },
+  },
+);

package/package.json

@@ -1,46 +1,58 @@
 {
   "author": "Turo engineering",
   "description": "Turo eslint configuration for typescript",
+  "type": "module",
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "8.23.0",
-    "@typescript-eslint/parser": "8.23.0",
+    "@eslint/js": "9.19.0",
+    "typescript-eslint": "8.22.0",
+    "@typescript-eslint/eslint-plugin": "8.22.0",
+    "@typescript-eslint/parser": "8.22.0",
     "eslint-config-prettier": "10.0.1",
     "eslint-import-resolver-typescript": "3.7.0",
     "eslint-plugin-import": "2.31.0",
     "eslint-plugin-jest": "28.11.0",
     "eslint-plugin-json": "4.0.1",
     "eslint-plugin-n": "17.15.1",
+    "eslint-plugin-perfectionist": "4.7.0",
     "eslint-plugin-prettier": "5.2.3",
-    "eslint-plugin-simple-import-sort": "12.1.1",
     "eslint-plugin-sonarjs": "3.0.1",
-    "eslint-plugin-sort-destructure-keys": "2.0.0",
-    "eslint-plugin-typescript-sort-keys": "3.3.0",
     "eslint-plugin-unicorn": "56.0.1"
   },
   "devDependencies": {
-    "eslint": "8.57.1",
+    "eslint": "9.19.0",
     "jest": "29.7.0",
     "prettier": "3.4.2"
   },
   "engines": {
-    "node": ">= 14"
+    "node": ">= 20"
   },
   "homepage": "https://github.com/open-turo/eslint-config-typescript#readme",
   "license": "MIT",
-  "main": "index.js",
+  "main": "index.cjs",
+  "module": "index.mjs",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.cjs",
+      "default": "./index.mjs"
+    },
+    "./legacy": {
+      "require": "./legacy.cjs"
+    }
+  },
   "name": "@open-turo/eslint-config-typescript",
   "scripts": {
     "build": "echo noop",
-    "lint": "echo noop",
-    "test": "jest ./test/test.spec.js"
+    "lint": "eslint './*.{cjs,mjs}' test/test.spec.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "peerDependencies": {
-    "eslint": "^8.18.0",
+    "eslint": "^8.18.0 || ^9.0.0",
     "prettier": "^3.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "repository": "https://github.com/open-turo/eslint-config-typescript",
-  "version": "15.0.1"
+  "version": "16.0.0-pr-373.4.1.1"
 }

package/{index.js → recommended.cjs}

@@ -12,11 +12,9 @@ module.exports = {
     "jest",
     "json",
     "n",
+    "perfectionist",
     "prettier",
-    "simple-import-sort",
     "sonarjs",
-    "sort-destructure-keys",
-    "typescript-sort-keys",
     "unicorn",
   ],
   extends: [
@@ -28,9 +26,9 @@ module.exports = {
     "plugin:jest/recommended",
     "plugin:json/recommended-legacy",
     "plugin:n/recommended",
+    "plugin:perfectionist/recommended-alphabetical-legacy",
     "plugin:prettier/recommended",
     "plugin:sonarjs/recommended-legacy",
-    "plugin:typescript-sort-keys/recommended",
     "plugin:unicorn/recommended",
   ],
   parserOptions: {
@@ -69,9 +67,6 @@ module.exports = {
     ],
     "n/no-unsupported-features/es-syntax": "off",
     "n/no-missing-import": "off",
-    "simple-import-sort/imports": "error",
-    "simple-import-sort/exports": "error",
-    "sort-destructure-keys/sort-destructure-keys": "error",
     // Noisy rule - we may have helpers/methods that we mark as @deprecated but aren't planning to remove in the near future. This rule also significantly adds to eslint running time, which slows down both local development and CI.
     "sonarjs/deprecation": "off",
     // This rule is not helpful in TypeScript files, and in JavaScript we often return different types from functions, so this is not a strictness level we want to enforce.

package/test/test.spec.js

@@ -1,30 +1,48 @@
-const fs = require("fs");
-const { ESLint } = require("eslint");
+import { loadESLint } from "eslint";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
 
 describe("validate config", () => {
-  it(`load config file in ESLint to validate all rules are correct`, async () => {
-    const stringConfig = fs.readFileSync("./test/sample.ts", "utf8");
-
-    const cli = new ESLint({
-      overrideConfigFile: "./index.js",
-    });
-
-    const calculatedConfig =
-      await cli.calculateConfigForFile("./test/sample.ts");
-
-    // remove parser property from calculated config because it is env specific (fails in CI)
-    const { parser, ...calculatedConfigWithoutParserProperty } =
-      calculatedConfig;
-    // print all the rules
-    expect(calculatedConfigWithoutParserProperty).toMatchSnapshot();
-
-    const lintResult = await cli.lintText(stringConfig);
-
-    /**
-     * We just need to validate a value is returned.
-     * If there is an issue with the config, `cli.lintText` will error,
-     * and we will never hit this line so the test will fail.
-     */
-    expect(lintResult).toBeTruthy();
-  });
+  test.each(["./index.mjs", "./index.cjs", "./recommended.cjs"])(
+    `load config file in ESLint to validate all rules are correct for %s`,
+    async (config) => {
+      const testFileName = "test.js";
+      const useFlatConfig = !config.includes("recommended");
+      const ESLint = await loadESLint({
+        useFlatConfig,
+      });
+      const linter = new ESLint({
+        // cwd: cwd,
+        overrideConfigFile: config,
+        overrideConfig: useFlatConfig
+          ? [
+              {
+                files: [testFileName],
+                languageOptions: {
+                  parserOptions: {
+                    projectService: {
+                      allowDefaultProject: [testFileName],
+                    },
+                  },
+                },
+              },
+            ]
+          : {
+              parserOptions: {
+                projectService: {
+                  allowDefaultProject: [testFileName],
+                },
+              },
+            },
+      });
+      const messages = await linter.lintText(
+        `const foo = 1;\nconsole.log(foo);\n`,
+        {
+          filePath: testFileName,
+        },
+      );
+      expect(messages[0].messages).toEqual([]);
+      expect(messages[0].errorCount).toEqual(0);
+    },
+  );
 });