@mlaursen/eslint-config 12.0.5 → 12.0.7

package/dist/recommended.js

@@ -1,45 +0,0 @@
-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));
-};
-import { scripts } from "./scripts.js";
-import { testing } from "./testing.js";
-import { typescript } from "./typescript.js";
-import { unicorn } from "./unicorn.js";
-/**
- * @example
- * ```ts
- * import { configs, gitignore } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   gitignore(import.meta.url),
- *   ...configs.recommended(),
- * ]);
- * ```
- */
-export var recommended = function (options) {
-    if (options === void 0) { options = {}; }
-    return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(typescript(options)), false), __read(scripts), false), __read(testing(options)), false), __read(unicorn), false);
-};

package/dist/recommendedFrontend.d.ts

@@ -1,18 +0,0 @@
-import { type Linter } from "eslint";
-import { type ReactOptions } from "./react.js";
-import { type RecommendedOptions } from "./recommended.js";
-export interface RecommendedFrontendOptions extends RecommendedOptions, ReactOptions {
-}
-/**
- * @example
- * ```ts
- * import { configs, gitignore } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   gitignore(import.meta.url),
- *   ...configs.recommendedFrontend(),
- * ]);
- * ```
- */
-export declare const recommendedFrontend: (options?: RecommendedFrontendOptions) => readonly Linter.Config[];

package/dist/recommendedFrontend.js

@@ -1,46 +0,0 @@
-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));
-};
-import { jsxA11y } from "./jsxA11y.js";
-import { mui } from "./mui.js";
-import { react } from "./react.js";
-import { recommended } from "./recommended.js";
-import { testingLibraryReact } from "./testing-library.js";
-/**
- * @example
- * ```ts
- * import { configs, gitignore } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   gitignore(import.meta.url),
- *   ...configs.recommendedFrontend(),
- * ]);
- * ```
- */
-export var recommendedFrontend = function (options) {
-    if (options === void 0) { options = {}; }
-    return __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(recommended(options)), false), __read(mui), false), __read(react(options)), false), __read(jsxA11y), false), __read(testingLibraryReact), false);
-};

package/dist/scripts.d.ts

@@ -1,11 +0,0 @@
-import { type Linter } from "eslint";
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig(configs.scripts);
- * ```
- */
-export declare const scripts: Linter.Config[];

package/dist/scripts.js

@@ -1,19 +0,0 @@
-import { BASE_NAME } from "./constants.js";
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig(configs.scripts);
- * ```
- */
-export var scripts = [
-    {
-        name: "".concat(BASE_NAME, "/scripts"),
-        files: ["scripts/**"],
-        rules: {
-            "no-console": "off",
-        },
-    },
-];

package/dist/testing-library.d.ts

@@ -1,35 +0,0 @@
-import { type Linter } from "eslint";
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   ...configs.react,
- *   ...configs.jest,
- *   ...configs.jestDom,
- *   ...configs.testingLibraryReact
- * ]);
- * ```
- *
- * NOTE: Only choose this or the {@link testingLibraryDom}. Do not use
- * both.
- */
-export declare const testingLibraryReact: Linter.Config[];
-/**
- * @example
- * ```ts
- * import { configs, defineConfig } from "@mlaursen/eslint-config";
- *
- * export default defineConfig([
- *   ...configs.jest,
- *   ...configs.jestDom,
- *   ...configs.testingLibraryDom
- * ]);
- * ```
- *
- * NOTE: Only choose this or the {@link testingLibraryReact}. Do not use
- * both.
- */
-export declare const testingLibraryDom: Linter.Config[];

package/dist/testing-library.js

@@ -1,57 +0,0 @@
-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);
-};
-import testingLibraryPlugin from "eslint-plugin-testing-library";
-import { BASE_NAME, TEST_FILES } from "./constants.js";
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   ...configs.react,
- *   ...configs.jest,
- *   ...configs.jestDom,
- *   ...configs.testingLibraryReact
- * ]);
- * ```
- *
- * NOTE: Only choose this or the {@link testingLibraryDom}. Do not use
- * both.
- */
-export var testingLibraryReact = [
-    __assign(__assign({ name: "".concat(BASE_NAME, "/testing-library/react"), files: TEST_FILES }, testingLibraryPlugin.configs["flat/react"]), { rules: __assign(__assign({}, testingLibraryPlugin.configs["flat/react"].rules), { 
-            // it can be useful to reassign screen.* queries without reusing to
-            // verify it still exists
-            "no-useless-assignment": "off" }) }),
-];
-/**
- * @example
- * ```ts
- * import { configs, defineConfig } from "@mlaursen/eslint-config";
- *
- * export default defineConfig([
- *   ...configs.jest,
- *   ...configs.jestDom,
- *   ...configs.testingLibraryDom
- * ]);
- * ```
- *
- * NOTE: Only choose this or the {@link testingLibraryReact}. Do not use
- * both.
- */
-export var testingLibraryDom = [
-    __assign(__assign({ name: "".concat(BASE_NAME, "/testing-library/dom"), files: TEST_FILES }, testingLibraryPlugin.configs["flat/dom"]), { rules: __assign(__assign({}, testingLibraryPlugin.configs["flat/dom"].rules), { 
-            // it can be useful to reassign screen.* queries without reusing to
-            // verify it still exists
-            "no-useless-assignment": "off" }) }),
-];

package/dist/testing.d.ts

@@ -1,54 +0,0 @@
-import { type Linter } from "eslint";
-export type TestFramework = "jest" | "vitest";
-export interface TestOptions {
-    /**
-     * @defaultValue `"vitest"`
-     */
-    testFramework?: TestFramework;
-}
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig(configs.vitest);
- * ```
- */
-export declare const vitest: Linter.Config[];
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig(configs.jest);
- * ```
- */
-export declare const jest: Linter.Config[];
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   ...configs.jest,
- *   ...configs.jestDom,
- * ]);
- * ```
- */
-export declare const jestDom: Linter.Config[];
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig(configs.testing({ testFramework: "jest" }));
- *
- * // or
- * export default defineConfig(configs.testing({ testFramework: "vitest" }));
- * ```
- */
-export declare const testing: (options?: TestOptions) => Linter.Config[];

package/dist/testing.js

@@ -1,112 +0,0 @@
-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 __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));
-};
-import vitestPlugin from "@vitest/eslint-plugin";
-import jestPlugin from "eslint-plugin-jest";
-import jestDomPlugin from "eslint-plugin-jest-dom";
-import { BASE_NAME, DEV_OFF_PROD_ERROR, TEST_FILES } from "./constants.js";
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig(configs.vitest);
- * ```
- */
-export var vitest = [
-    {
-        name: "".concat(BASE_NAME, "/vitest"),
-        files: TEST_FILES,
-        plugins: {
-            vitest: vitestPlugin,
-        },
-        rules: __assign(__assign({}, vitestPlugin.configs.recommended.rules), { "vitest/no-alias-methods": "error", "vitest/no-focused-tests": DEV_OFF_PROD_ERROR, "vitest/no-disabled-tests": DEV_OFF_PROD_ERROR, "vitest/no-duplicate-hooks": "error", "vitest/no-standalone-expect": "error", "vitest/prefer-expect-resolves": "error", "vitest/prefer-spy-on": "error", "vitest/prefer-vi-mocked": "error" }),
-    },
-];
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig(configs.jest);
- * ```
- */
-export var jest = [
-    __assign({ name: "".concat(BASE_NAME, "/jest"), files: TEST_FILES }, jestPlugin.configs["flat/recommended"]),
-];
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   ...configs.jest,
- *   ...configs.jestDom,
- * ]);
- * ```
- */
-export var jestDom = [
-    __assign({ name: "".concat(BASE_NAME, "/jest-dom"), files: TEST_FILES }, jestDomPlugin.configs["flat/recommended"]),
-];
-/**
- * @example
- * ```ts
- * import { configs } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig(configs.testing({ testFramework: "jest" }));
- *
- * // or
- * export default defineConfig(configs.testing({ testFramework: "vitest" }));
- * ```
- */
-export var testing = function (options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.testFramework, testFramework = _a === void 0 ? "vitest" : _a;
-    var config;
-    switch (testFramework) {
-        case "jest":
-            config = jest;
-            break;
-        case "vitest":
-            config = vitest;
-            break;
-    }
-    return __spreadArray(__spreadArray([], __read(config), false), __read(jestDom), false);
-};

package/dist/typescript.d.ts

@@ -1,41 +0,0 @@
-import { type Linter } from "eslint";
-export interface TypescriptOptions {
-    /**
-     * This is required when working in monorepos or when the
-     * {@link strictTypeChecked} rules are enabled.
-     *
-     * @example
-     * ```js
-     * configs.recommended({
-     *   tsconfigRootDir: import.meta.dirname,
-     * })
-     * ```
-     */
-    tsconfigRootDir?: string;
-    /**
-     * The {@link tsconfigRootDir} must be set if this is `true`.
-     *
-     * @example
-     * ```js
-     * configs.recommended({
-     *   tsconfigRootDir: import.meta.dirname,
-     *   strictTypeChecked: process.env.STRICT_TYPING === "true",
-     * })
-     *
-     * @defaultValue `false`
-     */
-    strictTypeChecked?: boolean;
-}
-/**
- * @example
- * ```ts
- * import { configs, gitignore } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   gitignore(import.meta.url),
- *   ...configs.typescript(),
- * ]);
- * ```
- */
-export declare const typescript: (options?: TypescriptOptions) => Linter.Config[];

package/dist/typescript.js

@@ -1,161 +0,0 @@
-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));
-};
-import tseslint from "typescript-eslint";
-import { base } from "./base.js";
-import { BASE_NAME, TEST_FILES, TS_FILES, VITE_MAIN_FILES, } from "./constants.js";
-/**
- * @example
- * ```ts
- * import { configs, gitignore } from "@mlaursen/eslint-config";
- * import { defineConfig } from "eslint/config";
- *
- * export default defineConfig([
- *   gitignore(import.meta.url),
- *   ...configs.typescript(),
- * ]);
- * ```
- */
-export var typescript = function (options) {
-    if (options === void 0) { options = {}; }
-    var tsconfigRootDir = options.tsconfigRootDir, strictTypeChecked = options.strictTypeChecked;
-    var configs = __spreadArray(__spreadArray(__spreadArray([], __read(base), false), __read(tseslint.configs.strict), false), [
-        {
-            name: "".concat(BASE_NAME, "/typescript"),
-            files: TS_FILES,
-            rules: {
-                // I normally do not want unified signatures since it helps improve type
-                // inference with function overloading
-                "@typescript-eslint/unified-signatures": "off",
-                // 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: "^_",
-                    },
-                ],
-                "no-use-before-define": "off",
-                "@typescript-eslint/no-use-before-define": [
-                    "warn",
-                    { ignoreTypeReferences: true },
-                ],
-            },
-        },
-        {
-            name: "".concat(BASE_NAME, "/typescript/tests"),
-            files: 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",
-            },
-        },
-        {
-            name: "".concat(BASE_NAME, "/typescript/vite"),
-            files: VITE_MAIN_FILES,
-            rules: {
-                // allow `createRoot(document.getElementById("root")).render(...)` for
-                // `vite` without disabling eslint
-                "@typescript-eslint/no-non-null-assertion": "off",
-            },
-        },
-    ], false);
-    if (tsconfigRootDir) {
-        configs.push({
-            name: "".concat(BASE_NAME, "/typescript-type-checking-language-options"),
-            languageOptions: {
-                parserOptions: {
-                    projectService: strictTypeChecked,
-                    tsconfigRootDir: tsconfigRootDir,
-                },
-            },
-        });
-    }
-    if (strictTypeChecked) {
-        configs.push.apply(configs, __spreadArray(__spreadArray([], __read(tseslint.configs.strictTypeCheckedOnly), false), [{
-                name: "".concat(BASE_NAME, "/typescript-type-checking"),
-                files: TS_FILES,
-                rules: {
-                    // I do not enable the `noUncheckedIndexedAccess` tsconfig option, so I
-                    // still need to verify that stuff exists. There are other cases where I
-                    // know it exists, so I can ignore those as well
-                    "@typescript-eslint/no-unnecessary-condition": "off",
-                    // I never use `this`
-                    "@typescript-eslint/unbound-method": "off",
-                    "@typescript-eslint/restrict-template-expressions": [
-                        "error",
-                        {
-                            allowNumber: true,
-                        },
-                    ],
-                    // I want to allow `onClick={async (event) => { ... }}`
-                    "@typescript-eslint/no-misused-promises": [
-                        "error",
-                        {
-                            checksVoidReturn: false,
-                        },
-                    ],
-                },
-            },
-            {
-                name: "".concat(BASE_NAME, "/typescript-type-checking/tests"),
-                files: TEST_FILES,
-                rules: {
-                    // like base typescript, can be less strict in tests
-                    "@typescript-eslint/no-unsafe-return": "off",
-                    "@typescript-eslint/no-unsafe-assignment": "off",
-                    "@typescript-eslint/restrict-template-expressions": "off",
-                },
-            }], false));
-    }
-    return configs;
-};

package/dist/unicorn.d.ts

@@ -1,2 +0,0 @@
-import { type Linter } from "eslint";
-export declare const unicorn: Linter.Config[];

package/dist/unicorn.js

@@ -1,56 +0,0 @@
-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);
-};
-import { BASE_NAME, TEST_FILES, VITE_MAIN_FILES } from "./constants.js";
-import eslintPluiginUnicorn from "eslint-plugin-unicorn";
-export var unicorn = [
-    __assign(__assign({}, eslintPluiginUnicorn.configs.recommended), { name: "".concat(BASE_NAME, "/unicorn"), rules: __assign(__assign({}, eslintPluiginUnicorn.configs.recommended.rules), { 
-            //  this flags `dist` and `dest` which is annoying
-            "unicorn/prevent-abbreviations": "off", 
-            // I do not like using the default exports from `node:path`, `node:fs`,
-            // etc
-            "unicorn/import-style": "off", 
-            // I want PascalCase for React components/classes, camelCase for others.
-            // Don't care enough to enforce through a rule and don't think it's
-            // possible.
-            "unicorn/filename-case": "off", 
-            // prettier instead
-            "unicorn/empty-brace-spaces": "off", 
-            // I like `null`
-            "unicorn/no-null": "off", 
-            // the description is incorrect since it attempts converting multi-line
-            // statements to ternary which is awful:
-            //
-            // > This rule enforces the use of ternary expressions over 'simple'
-            // > if-else statements, where 'simple' means the consequent and alternate
-            // > are each one line and have the same basic type and form.
-            "unicorn/prefer-ternary": "off", 
-            // I don't care about adding braces to switch cases. I'd prefer
-            // `["error", "avoid"]` more though since it only adds them when needed.
-            "unicorn/switch-case-braces": "off" }) }),
-    {
-        name: "".concat(BASE_NAME, "/unicorn/vite"),
-        files: VITE_MAIN_FILES,
-        rules: {
-            // allow `createRoot(document.getElementById("root")).render(...)` for
-            // `vite` without disabling eslint
-            "unicorn/prefer-query-selector": "off",
-        },
-    },
-    {
-        name: "".concat(BASE_NAME, "/unicorn/testing"),
-        files: TEST_FILES,
-        rules: {
-            // allow functions to be scoped to tests
-            "unicorn/consistent-function-scoping": "off",
-        },
-    },
-];