@mlaursen/eslint-config 4.2.0 → 5.1.0

package/README.md

@@ -2,36 +2,161 @@
 
 A reusable eslint config that I use for most of my projects.
 
-## Usage
-
-```js
-module.exports = {
-  extends: "@mlaursen/eslint-config",
-};
-```
-
-## Additional Type Checking
-
-Or if I want to do additional rules and strict type checking linting rules:
-
-```js
-module.exports = {
-  extends: "@mlaursen/eslint-config",
-  parserOptions: {
-    tsconfigRootDir: __dirname,
-    project: ["./tsconfig.json"],
-  },
-  rules: {
-    // any custom rules for this project
-  },
-  overrides: [
-    {
-      files: ["**/*.ts", "**/*.tsx"],
-      extends: [
-        "plugin:@typescript-eslint/recommended-requiring-type-checking",
-      ],
-    },
-    // any custom overrides for this project
-  ],
-};
+Starting at `5.0.0`, I only support `eslint@^9` or greater.
+
+## Installation
+
+```sh
+npm install -D eslint @mlaursen/eslint-config
+```
+
+Then create an `eslint.config.mjs` with the following:
+
+```js
+// @ts-check
+import { config, configs, gitignore } from "@mlaursen/eslint-config";
+
+// choose the config you want to use
+export default config(gitignore(import.meta.url), ...configs.frontend);
+export default config(gitignore(import.meta.url), ...configs.frontendTypeChecking(import.meta.dirname));
+```
+
+The `config` export is the `typescript-eslint.config()` function to provide
+type definitions.
+
+## Configs
+
+I normally just use the `frontend` or `frontendTypeChecking` configs, but the others can be used individually if needed.
+
+<!--toc:start-->
+
+- [base](#base)
+- [typescript](#typescript)
+- [typescriptTypeChecking](#typescripttypechecking)
+- [jest](#jest)
+- [jestDom](#jestdom)
+- [testingLibraryReact](#testinglibraryreact)
+- [testingLibraryDom](#testinglibrarydom)
+- [frontend](#frontend)
+- [frontendTypeChecking](#frontendtypechecking)
+
+<!--toc:end-->
+
+### base
+
+The base config is automatically used by the [typescript](#typescript) config and is just the `eslint.configs.recommended` and a few other stylistic changes.
+
+> This should not be used if the [typescript](#typescript) or [typescriptTypeChecking](#typescripttypechecking) configs are used.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.base);
+```
+
+### typescript
+
+This extends the [base](#base) config and the `tseslint.configs.strict` config. It also includes a few stylistic choices for type
+behavior and disabled strict rules in test files.
+
+> Only this rule or [typescripttypechecking](#typescripttypechecking) should be used. They should not be used together.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.typescript);
+```
+
+### typescriptTypeChecking
+
+This is the same as the [typescript](#typescript) config but also includes the `tseslint.configs.strictTypeCheckedOnly` config.
+
+> Only this rule or [typescript](#typescript) should be used. They should not be used together.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.typescriptTypeChecking(import.meta.dirname));
+```
+
+### jest
+
+This only enables the `eslint-plugin-jest.configs['flat/recommended]` rules on tests files.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.jest);
+```
+
+### jestDom
+
+This only enables the `eslint-plugin-jest-dom.configs['flat/recommended]` rules on tests files.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.jestDom);
+```
+
+### testingLibraryReact
+
+This enables the `eslint-plugin-testing-library/.configs["flat/react]` plugin and rules on test files.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.testingLibraryReact);
+```
+
+### testingLibraryDom
+
+This enables the `eslint-plugin-testing-library/.configs["flat/dom]` plugin and rules on test files.
+
+> This should **not** be used with the [testingLibraryReact](#testinglibraryreact) rules
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.testingLibraryDom);
+```
+
+### next
+
+This is a small wrapper around the `@next/eslint-plugin-next` that works with eslint v9.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.next);
+```
+
+### frontend
+
+This is my normal frontend repo setup with `jest`, `jest-dom`, `typescript`, `react`, `testing-library/react`.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.frontend);
+```
+
+### frontendTypeChecking
+
+Same as the [frontend](#frontend), but enables the strict type checking.
+
+```js
+// @ts-check
+import { config, configs } from "@mlaursen/eslint-config";
+
+export default config(...configs.frontendTypeChecking(import.meta.dirname));
 ```

package/dist/base.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const base: TSESLint.FlatConfig.ConfigArray;

package/dist/base.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base = void 0;
+var js_1 = __importDefault(require("@eslint/js"));
+var constants_1 = require("./constants");
+exports.base = [
+    js_1.default.configs.recommended,
+    {
+        rules: {
+            // You normally do not want `console.{whatever}` in prod but is fine for
+            // development in debugging
+            "no-console": constants_1.DEV_WARNING_PROD_ERROR,
+            "no-use-before-define": "warn",
+            // I want to enforce all statements to require curly braces even if it
+            // could be omitted for consistency
+            curly: "error",
+            // Since this is auto-fixable, I like `{ someproperty }` instead of
+            // `{ someproperty: someproperty }`
+            "object-shorthand": ["error", "always"],
+            // This is about the same as `object-shorthand`. Only rename if it has to
+            // be renamed
+            "no-useless-rename": ["error"],
+        },
+    },
+];

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEV_WARNING_PROD_ERROR: string;
+export declare const TEST_FILES: string[];

package/dist/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_FILES = exports.DEV_WARNING_PROD_ERROR = void 0;
+exports.DEV_WARNING_PROD_ERROR = process.env.NODE_ENV !== "production" ? "warn" : "error";
+exports.TEST_FILES = [
+    "**/__tests__/**",
+    "**/*.{spec,test}.{ts,tsx,js,jsx}",
+];

package/dist/frontend.d.ts

@@ -0,0 +1,3 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const frontend: TSESLint.FlatConfig.ConfigArray;
+export declare const frontendTypeChecking: (tsconfigRootDir: string) => TSESLint.FlatConfig.ConfigArray;

package/dist/frontend.js

@@ -0,0 +1,34 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frontendTypeChecking = exports.frontend = void 0;
+var jest_1 = require("./jest");
+var testing_library_1 = require("./testing-library");
+var typescript_1 = require("./typescript");
+exports.frontend = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(typescript_1.typescript), false), __read(jest_1.jest), false), __read(jest_1.jestDom), false), __read(testing_library_1.testingLibraryReact), false);
+var frontendTypeChecking = function (tsconfigRootDir) { return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((0, typescript_1.typescriptTypeChecking)(tsconfigRootDir)), false), __read(jest_1.jest), false), __read(jest_1.jestDom), false), __read(testing_library_1.testingLibraryReact), false); };
+exports.frontendTypeChecking = frontendTypeChecking;

package/dist/gitignore.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare function gitignore(importMetaUrl: string): TSESLint.FlatConfig.Config;

package/dist/gitignore.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitignore = gitignore;
+var compat_1 = require("@eslint/compat");
+var node_path_1 = __importDefault(require("node:path"));
+var node_url_1 = require("node:url");
+function gitignore(importMetaUrl) {
+    var __filename = (0, node_url_1.fileURLToPath)(importMetaUrl);
+    var __dirname = node_path_1.default.dirname(__filename);
+    var gitignorePath = node_path_1.default.resolve(__dirname, ".gitignore");
+    return (0, compat_1.includeIgnoreFile)(gitignorePath);
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { config } from "typescript-eslint";
+export { gitignore } from "./gitignore";
+export declare const configs: {
+    readonly base: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly jest: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly jestDom: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly typescript: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly typescriptTypeChecking: (tsconfigRootDir: string) => import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly testingLibraryDom: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly testingLibraryReact: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly frontend: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly frontendTypeChecking: (tsconfigRootDir: string) => import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+    readonly next: import("@typescript-eslint/utils/ts-eslint").FlatConfig.ConfigArray;
+};

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configs = exports.gitignore = exports.config = void 0;
+var base_1 = require("./base");
+var frontend_1 = require("./frontend");
+var jest_1 = require("./jest");
+var next_1 = require("./next");
+var testing_library_1 = require("./testing-library");
+var typescript_1 = require("./typescript");
+var typescript_eslint_1 = require("typescript-eslint");
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return typescript_eslint_1.config; } });
+var gitignore_1 = require("./gitignore");
+Object.defineProperty(exports, "gitignore", { enumerable: true, get: function () { return gitignore_1.gitignore; } });
+exports.configs = {
+    base: base_1.base,
+    jest: jest_1.jest,
+    jestDom: jest_1.jestDom,
+    typescript: typescript_1.typescript,
+    typescriptTypeChecking: typescript_1.typescriptTypeChecking,
+    testingLibraryDom: testing_library_1.testingLibraryDom,
+    testingLibraryReact: testing_library_1.testingLibraryReact,
+    frontend: frontend_1.frontend,
+    frontendTypeChecking: frontend_1.frontendTypeChecking,
+    next: next_1.next,
+};

package/dist/jest.d.ts

@@ -0,0 +1,3 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const jest: TSESLint.FlatConfig.ConfigArray;
+export declare const jestDom: TSESLint.FlatConfig.ConfigArray;

package/dist/jest.js

@@ -0,0 +1,26 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jestDom = exports.jest = void 0;
+var eslint_plugin_jest_1 = __importDefault(require("eslint-plugin-jest"));
+var eslint_plugin_jest_dom_1 = __importDefault(require("eslint-plugin-jest-dom"));
+var constants_1 = require("./constants");
+exports.jest = [
+    __assign({ files: constants_1.TEST_FILES }, eslint_plugin_jest_1.default.configs["flat/recommended"]),
+];
+exports.jestDom = [
+    __assign({ files: constants_1.TEST_FILES }, eslint_plugin_jest_dom_1.default.configs["flat/recommended"]),
+];

package/dist/next.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const next: TSESLint.FlatConfig.ConfigArray;

package/dist/next.js

@@ -0,0 +1,28 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.next = void 0;
+var compat_1 = require("@eslint/compat");
+var eslint_plugin_next_1 = __importDefault(require("@next/eslint-plugin-next"));
+exports.next = [
+    {
+        plugins: {
+            // @ts-expect-error There is a bad typing atm
+            "@next/next": (0, compat_1.fixupPluginRules)(eslint_plugin_next_1.default),
+        },
+        rules: __assign({}, eslint_plugin_next_1.default.configs.recommended.rules),
+    },
+];

package/dist/react-hooks.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const reactHooks: TSESLint.FlatConfig.ConfigArray;

package/dist/react-hooks.js

@@ -0,0 +1,27 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactHooks = void 0;
+var eslint_plugin_react_hooks_1 = __importDefault(require("eslint-plugin-react-hooks"));
+exports.reactHooks = [
+    {
+        files: ["**/*.{ts,tsx,js,jsx}"],
+        plugins: {
+            "react-hooks": eslint_plugin_react_hooks_1.default,
+        },
+        rules: __assign({}, eslint_plugin_react_hooks_1.default.configs.recommended.rules),
+    },
+];

package/dist/testing-library.d.ts

@@ -0,0 +1,11 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+/**
+ * NOTE: Only choose this or the {@link testingLibraryDom}. Do not use
+ * both.
+ */
+export declare const testingLibraryReact: TSESLint.FlatConfig.ConfigArray;
+/**
+ * NOTE: Only choose this or the {@link testingLibraryReact}. Do not use
+ * both.
+ */
+export declare const testingLibraryDom: TSESLint.FlatConfig.ConfigArray;

package/dist/testing-library.js

@@ -0,0 +1,41 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testingLibraryDom = exports.testingLibraryReact = void 0;
+var compat_1 = require("@eslint/compat");
+var eslint_plugin_testing_library_1 = __importDefault(require("eslint-plugin-testing-library"));
+var constants_1 = require("./constants");
+var testingLibrary = {
+    files: constants_1.TEST_FILES,
+    plugins: {
+        // @ts-expect-error There is a bad typing atm
+        "testing-library": (0, compat_1.fixupPluginRules)(eslint_plugin_testing_library_1.default),
+    },
+};
+/**
+ * NOTE: Only choose this or the {@link testingLibraryDom}. Do not use
+ * both.
+ */
+exports.testingLibraryReact = [
+    __assign(__assign({}, testingLibrary), { rules: __assign({}, eslint_plugin_testing_library_1.default.configs["flat/react"].rules) }),
+];
+/**
+ * NOTE: Only choose this or the {@link testingLibraryReact}. Do not use
+ * both.
+ */
+exports.testingLibraryDom = [
+    __assign(__assign({}, testingLibrary), { rules: __assign({}, eslint_plugin_testing_library_1.default.configs["flat/dom"].rules) }),
+];

package/dist/typescript.d.ts

@@ -0,0 +1,12 @@
+import { type TSESLint } from "@typescript-eslint/utils";
+export declare const typescript: TSESLint.FlatConfig.ConfigArray;
+/**
+ * @example
+ * ```ts
+ * // @ts-check
+ * import { config, configs } from "@mlaursen/eslint-config";
+ *
+ * export default config(...configs.typescriptTypeChecking(import.meta.dirname));
+ * ```
+ */
+export declare const typescriptTypeChecking: (tsconfigRootDir: string) => TSESLint.FlatConfig.ConfigArray;

package/dist/typescript.js

@@ -0,0 +1,104 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptTypeChecking = exports.typescript = void 0;
+var typescript_eslint_1 = __importDefault(require("typescript-eslint"));
+var base_1 = require("./base");
+var constants_1 = require("./constants");
+exports.typescript = __spreadArray(__spreadArray(__spreadArray([], __read(base_1.base), false), __read(typescript_eslint_1.default.configs.strict), false), [
+    {
+        files: ["**/*.{ts,tsx}"],
+        rules: {
+            // I prefer specifying when something is used only as a type
+            "@typescript-eslint/consistent-type-imports": [
+                "error",
+                { fixStyle: "inline-type-imports" },
+            ],
+            // I prefer shorthand syntax
+            "@typescript-eslint/array-type": ["error", { default: "array" }],
+            // I prefer using `interface` over `type = {}`
+            "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+            // Allow expressions to work with react hooks. Annoying to have to
+            // typedef each arrow function in a `useEffect` or `useCallback` when
+            // it can be derived.
+            "@typescript-eslint/explicit-function-return-type": [
+                "error",
+                {
+                    allowExpressions: true,
+                    // allow FC definitions for React
+                    allowTypedFunctionExpressions: true,
+                },
+            ],
+            "@typescript-eslint/no-unused-vars": [
+                "error",
+                {
+                    argsIgnorePattern: "^_",
+                    varsIgnorePattern: "^_",
+                },
+            ],
+            "@typescript-eslint/no-use-before-define": [
+                "warn",
+                { ignoreTypeReferences: true },
+            ],
+        },
+    },
+    {
+        files: constants_1.TEST_FILES,
+        rules: {
+            // allow tests to be less strict
+            "@typescript-eslint/ban-ts-comment": "off",
+            "@typescript-eslint/explicit-function-return-type": "off",
+            "@typescript-eslint/no-empty-function": "off",
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-object-literal-type-assertion": "off",
+            "@typescript-eslint/no-var-requires": "off",
+        },
+    },
+], false);
+/**
+ * @example
+ * ```ts
+ * // @ts-check
+ * import { config, configs } from "@mlaursen/eslint-config";
+ *
+ * export default config(...configs.typescriptTypeChecking(import.meta.dirname));
+ * ```
+ */
+var typescriptTypeChecking = function (tsconfigRootDir) { return __spreadArray(__spreadArray(__spreadArray([], __read(exports.typescript), false), __read(typescript_eslint_1.default.configs.strictTypeCheckedOnly), false), [
+    {
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                tsconfigRootDir: tsconfigRootDir,
+            },
+        },
+    },
+], false); };
+exports.typescriptTypeChecking = typescriptTypeChecking;

package/package.json

@@ -1,25 +1,17 @@
 {
   "name": "@mlaursen/eslint-config",
-  "version": "4.2.0",
+  "version": "5.1.0",
   "description": "An eslint config used by mlaursen for most projects.",
-  "main": "index.js",
   "repository": "https://github.com/mlaursen/eslint-config.git",
   "author": "Mikkel Laursen <mlaursen03@gmail.com>",
   "license": "MIT",
-  "scripts": {
-    "test": "eslint -c index.js \"test/**/*.{js,jsx,ts,tsx}\"",
-    "lint": "eslint -c scripts/.eslintrc.js \"scripts/**/*.ts\"",
-    "run-script": "tsx --tsconfig scripts/tsconfig.json",
-    "release": "pnpm run run-script scripts/release.ts"
-  },
-  "engines": {
-    "pnpm": ">=7",
-    "node": ">=16"
-  },
-  "engineStrict": true,
   "files": [
-    "index.js"
+    "dist/"
   ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
   "bugs": {
     "url": "https://github.com/mlaursen/eslint-config/issues"
   },
@@ -28,33 +20,33 @@
     "typescript"
   ],
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^7.16.0",
-    "@typescript-eslint/parser": "^7.16.0",
-    "confusing-browser-globals": "^1.0.11",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jest": "^28.6.0",
-    "eslint-plugin-jsx-a11y": "^6.9.0",
-    "eslint-plugin-react": "^7.34.4",
-    "eslint-plugin-react-hooks": "^4.6.2",
-    "eslint-plugin-testing-library": "^6.2.2",
-    "eslint-plugin-tsdoc": "^0.3.0"
+    "@eslint/compat": "^1.2.0",
+    "@eslint/js": "^9.12.0",
+    "@next/eslint-plugin-next": "^14.2.15",
+    "@types/eslint__js": "^8.42.3",
+    "@typescript-eslint/utils": "^8.8.1",
+    "eslint-plugin-jest": "^28.8.3",
+    "eslint-plugin-jest-dom": "^5.4.0",
+    "eslint-plugin-react-hooks": "^5.0.0",
+    "eslint-plugin-testing-library": "^6.3.0",
+    "typescript-eslint": "^8.8.1"
   },
   "devDependencies": {
-    "@mlaursen/changelog-preset": "^1.1.0",
+    "@changesets/cli": "^2.27.9",
+    "@inquirer/prompts": "^7.0.0",
     "@octokit/core": "^6.1.2",
-    "@swc/core": "^1.6.13",
-    "@types/inquirer": "^9.0.7",
     "@types/node": "^20.14.10",
     "dotenv": "^16.4.5",
-    "eslint": "^8.57.0",
-    "inquirer": "^8.2.6",
-    "standard-version": "^9.5.0",
-    "tsx": "^4.16.2",
-    "typescript": "^5.5.3"
+    "eslint": "^9.12.0",
+    "husky": "^9.1.6",
+    "inquirer": "^12.0.0",
+    "lint-staged": "^15.2.10",
+    "prettier": "^3.3.3",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.3"
   },
   "peerDependencies": {
-    "eslint": ">= 8.0.0",
+    "eslint": ">= 9.0.0",
     "typescript": ">= 5"
   },
   "peerDependenciesMeta": {
@@ -68,8 +60,19 @@
   "publishConfig": {
     "access": "public"
   },
+  "lint-staged": {
+    "**/*.{js,jsx,ts,tsx,md,yml,yaml,json}": [
+      "prettier --write"
+    ]
+  },
   "volta": {
-    "node": "20.15.1",
-    "pnpm": "9.5.0"
+    "node": "20.12.2",
+    "pnpm": "9.12.1"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsc -p tsconfig.build.json",
+    "run-script": "tsx --tsconfig scripts/tsconfig.json",
+    "release": "pnpm run run-script scripts/release.ts"
   }
-}
+}

package/index.js

@@ -1,184 +0,0 @@
-const confusingBrowserGlobals = require("confusing-browser-globals");
-
-let react = false;
-let isNewJsx = false;
-try {
-  require.resolve("react");
-  react = true;
-  isNewJsx = parseInt(require("react").version, 10) > 16;
-} catch (e) {}
-
-module.exports = {
-  parser: "@typescript-eslint/parser",
-  parserOptions: {
-    ecmaVersion: 2018,
-    sourceType: "module",
-  },
-  extends: [
-    "eslint:recommended",
-    "plugin:react/recommended",
-    "plugin:react-hooks/recommended",
-    isNewJsx && "plugin:react/jsx-runtime",
-    "plugin:import/errors",
-    "plugin:import/warnings",
-    "plugin:import/typescript",
-    "plugin:jsx-a11y/recommended",
-    "prettier",
-  ].filter(Boolean),
-  plugins: ["@typescript-eslint", "jest", "jsx-a11y", "react-hooks", "tsdoc"],
-  env: {
-    es6: true,
-    node: true,
-    browser: true,
-  },
-  settings: {
-    "import/extensions": [".js", ".jsx", ".ts", ".tsx", ".d.ts"],
-    "import/parsers": {
-      "@typescript-eslint/parser": [".ts", ".tsx"],
-    },
-    "import/resolver": {
-      node: {
-        extensions: [".js", ".jsx", ".ts", ".tsx"],
-      },
-    },
-    react: {
-      version: react ? "detect" : "17.0.0",
-    },
-  },
-  rules: {
-    "no-console": "warn",
-    "no-use-before-define": "warn",
-
-    "no-restricted-globals": ["error", "isFinite", "isNaN"].concat(
-      confusingBrowserGlobals
-    ),
-
-    // too many false positives with aliases/root dirs
-    "import/no-unresolved": "off",
-
-    curly: "error",
-
-    "object-shorthand": ["error", "always"],
-    "no-useless-rename": ["error"],
-  },
-  overrides: [
-    {
-      files: ["**/*.ts", "**/*.tsx"],
-      extends: ["plugin:@typescript-eslint/recommended"],
-      rules: {
-        "@typescript-eslint/consistent-type-imports": [
-          "error",
-          { fixStyle: "inline-type-imports" },
-        ],
-
-        // I want correct tsdoc syntax
-        "tsdoc/syntax": "warn",
-
-        "react/prop-types": "off",
-
-        // have to disable since it can report incorrect errors
-        "no-empty-function": "off",
-
-        // I prefer shorthand syntax
-        "@typescript-eslint/array-type": ["error", { default: "array" }],
-
-        // I prefer using `interface` over `type = {}`
-        "@typescript-eslint/consistent-type-definitions": [
-          "error",
-          "interface",
-        ],
-
-        // Allow expressions to work with react hooks. Annoying to have to
-        // typedef each arrow function in a `useEffect` or `useCallback` when
-        // it can be derived.
-        "@typescript-eslint/explicit-function-return-type": [
-          "error",
-          {
-            allowExpressions: true,
-            // allow FC definitions for React
-            allowTypedFunctionExpressions: true,
-          },
-        ],
-
-        // not a big fan of requiring unknown objects to require the index signature
-        "@typescript-eslint/ban-types": "off",
-
-        // This is a "better" version of the `noUnusedLocals` and
-        // `noUnusedParameters` from the tsconfig.json since it can catch
-        // unused vars in rest parameters that weren't meant to be omitted. I
-        // must manually rename to be _name so I know it was intentionally
-        // omitted
-        "@typescript-eslint/no-unused-vars": [
-          "error",
-          {
-            argsIgnorePattern: "^_",
-            varsIgnorePattern: "^_",
-          },
-        ],
-
-        "no-use-before-define": "off",
-        "@typescript-eslint/no-use-before-define": [
-          "warn",
-          { ignoreTypeReferences: true },
-        ],
-      },
-    },
-    {
-      files: [
-        "src/setupTests.js",
-        "src/setupTests.ts",
-        "**/__tests__/**",
-        "**/*.test.*",
-      ],
-      env: {
-        jest: true,
-      },
-      // allow for less strict rules when writing tests
-      rules: {
-        "prefer-template": "off",
-
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/explicit-function-return-type": "off",
-        "@typescript-eslint/no-object-literal-type-assertion": "off",
-        "@typescript-eslint/no-var-requires": "off",
-        "@typescript-eslint/no-empty-function": "off",
-        "@typescript-eslint/ban-ts-comment": "off",
-        "@typescript-eslint/no-empty-function": "off",
-
-        "jsx-a11y/anchor-has-content": 0,
-        "jsx-a11y/anchor-is-valid": "off",
-        "jsx-a11y/click-events-have-key-events": 0,
-        "jsx-a11y/control-has-associated-label": "off",
-        "jsx-a11y/no-autofocus": "off",
-        "jsx-a11y/no-static-element-interactions": "off",
-
-        "react/prop-types": "off",
-        "react/display-name": "off",
-        "react/prefer-stateless-function": "off",
-      },
-    },
-    {
-      files: ["**/__tests__/**", "**/*.test.*"],
-      extends: ["plugin:jest/recommended", "plugin:testing-library/react"],
-      rules: {
-        // it's valid to do @jest-environment or other things in tests
-        "tsdoc/syntax": 0,
-      },
-    },
-    {
-      files: ["**/*.js", "**/*.jsx"],
-      rules: {
-        "no-unused-vars": [
-          "error",
-          {
-            vars: "all",
-            varsIgnorePattern: "^_",
-            args: "after-used",
-            varsIgnorePattern: "^_",
-            ignoreRestSiblings: true,
-          },
-        ],
-      },
-    },
-  ],
-};