@richardscull/eslint-config 1.0.0

package/dist/index.js

@@ -0,0 +1,1120 @@
+import commandConfig from 'eslint-plugin-command/config';
+import pluginAntfu from 'eslint-plugin-antfu';
+import * as pluginImport from 'eslint-plugin-import-x';
+import simpleImportSort from 'eslint-plugin-simple-import-sort';
+import js from '@eslint/js';
+import globals from 'globals';
+import pluginJsonc from 'eslint-plugin-jsonc';
+import packageJson from 'eslint-plugin-package-json';
+import * as parserJsonc from 'jsonc-eslint-parser';
+import defu$1, { createDefu } from 'defu';
+import * as regexpPlugin from 'eslint-plugin-regexp';
+import pluginStylistic from '@stylistic/eslint-plugin';
+import pluginHyoban from 'eslint-plugin-hyoban';
+import typescriptEslint from 'typescript-eslint';
+import pluginUnicorn from 'eslint-plugin-unicorn';
+import pluginUnusedImports from 'eslint-plugin-unused-imports';
+import { isPackageExists, getPackageInfo } from 'local-pkg';
+import { readPackageUp } from 'read-package-up';
+
+function importConfig() {
+    return {
+        name: "extend/import",
+        plugins: {
+            "simple-import-sort": simpleImportSort,
+            "import-x": pluginImport,
+            "antfu": pluginAntfu
+        },
+        rules: {
+            "sort-imports": "off",
+            "import-x/order": "off",
+            "simple-import-sort/imports": "error",
+            "simple-import-sort/exports": "error",
+            "import-x/first": "error",
+            "import-x/newline-after-import": "error",
+            "no-duplicate-imports": "off",
+            "import-x/no-duplicates": "error",
+            "antfu/import-dedupe": "error",
+            "import-x/consistent-type-specifier-style": [
+                "error",
+                "prefer-top-level"
+            ],
+            "antfu/no-import-dist": "error",
+            "antfu/no-import-node-modules-by-path": "error"
+        }
+    };
+}
+
+const GLOB_TS_SRC = [
+    "**/*.cts",
+    "**/*.mts",
+    "**/*.ts",
+    "**/*.tsx"
+];
+const GLOB_JS_SRC = [
+    "**/*.cjs",
+    "**/*.mjs",
+    "**/*.js",
+    "**/*.jsx"
+];
+const GLOB_JSX_SRC = [
+    "**/*.jsx",
+    "**/*.tsx"
+];
+const GLOB_SRC = [
+    ...GLOB_TS_SRC,
+    ...GLOB_JS_SRC
+];
+const GLOB_JSON = "**/*.json";
+const GLOB_SHOULD_BE_JSONC = [
+    "**/tsconfig.json",
+    "**/tsconfig.*.json",
+    "**/.vscode/*.json"
+];
+const GLOB_JSON5 = "**/*.json5";
+const GLOB_JSONC = "**/*.jsonc";
+const GLOB_JSON_SRC = [
+    GLOB_JSON,
+    GLOB_JSON5,
+    GLOB_JSONC
+];
+const GLOB_EXCLUDE = [
+    "**/node_modules",
+    "**/dist",
+    "**/package-lock.json",
+    "**/yarn.lock",
+    "**/pnpm-lock.yaml",
+    "**/bun.lockb",
+    "**/output",
+    "**/coverage",
+    "**/temp",
+    "**/.temp",
+    "**/tmp",
+    "**/.tmp",
+    "**/.history",
+    "**/.vitepress/cache",
+    "**/.nuxt",
+    "**/.next",
+    "**/.vercel",
+    "**/.changeset",
+    "**/.idea",
+    "**/.cache",
+    "**/.output",
+    "**/.vite-inspect",
+    "**/.yarn",
+    "**/CHANGELOG*.md",
+    "**/*.min.*",
+    "**/LICENSE*",
+    "**/__snapshots__",
+    "**/auto-import?(s).d.ts",
+    "**/components.d.ts",
+    "**/eslint-typegen.d.ts"
+];
+const DEFAULT_IGNORE_FILES = [
+    ".gitignore",
+    ".eslintignore"
+];
+
+function javaScriptConfigs({ strict, restrictedSyntax, linterOptions, settings }) {
+    return [
+        /// keep-sorted
+        {
+            files: GLOB_SRC,
+            languageOptions: {
+                ecmaVersion: 2022,
+                globals: {
+                    ...globals.browser,
+                    ...globals.es2022,
+                    ...globals.node
+                },
+                parserOptions: {
+                    ecmaFeatures: {
+                        jsx: true
+                    },
+                    ecmaVersion: 2022,
+                    sourceType: "module"
+                },
+                sourceType: "module"
+            },
+            linterOptions,
+            name: strict ? "@eslint/js/all" : "@eslint/js/recommended",
+            rules: strict ? js.configs.all.rules : js.configs.recommended.rules,
+            settings
+        },
+        [
+            // we can enabled in stylistic config if needed
+            strict ? {
+                /// keep-sorted
+                rules: {
+                    "arrow-body-style": "off",
+                    "curly": "off",
+                    "func-style": "off",
+                    "no-empty-function": "off",
+                    "object-shorthand": "off",
+                    "prefer-destructuring": "off",
+                    "prefer-template": "off"
+                }
+            } : {},
+            // too opinionated, let this be decided by the user
+            strict ? {
+                /// keep-sorted
+                rules: {
+                    "camelcase": "off",
+                    "capitalized-comments": "off",
+                    "complexity": "off",
+                    "consistent-return": "off",
+                    "id-length": "off",
+                    "max-lines-per-function": "off",
+                    "max-lines": "off",
+                    "max-statements": "off",
+                    "no-implicit-coercion": "off",
+                    "no-inline-comments": "off",
+                    "no-magic-numbers": "off",
+                    "no-warning-comments": "off"
+                }
+            } : {},
+            // may not very useful
+            strict ? {
+                /// keep-sorted
+                rules: {
+                    "init-declarations": "off",
+                    "no-continue": "off",
+                    "no-shadow": "off",
+                    "no-ternary": "off",
+                    "no-undefined": "off",
+                    "no-underscore-dangle": "off",
+                    "no-useless-assignment": "off",
+                    "one-var": "off",
+                    "prefer-named-capture-group": "off",
+                    "require-unicode-regexp": "off",
+                    "sort-keys": "off",
+                    "sort-vars": "off"
+                }
+            } : {},
+            // change for more precise
+            strict ? {
+                /// keep-sorted
+                rules: {
+                    "no-void": [
+                        "error",
+                        {
+                            allowAsStatement: true
+                        }
+                    ]
+                }
+            } : {},
+            // all rules here are nice to have, let's enable them
+            {
+                name: "@eslint/js/custom",
+                /// keep-sorted
+                rules: {
+                    // https://twitter.com/karlhorky/status/1773632485055680875
+                    "array-callback-return": "error",
+                    "eqeqeq": [
+                        "error",
+                        "smart"
+                    ],
+                    "new-cap": [
+                        "error",
+                        {
+                            capIsNew: false,
+                            newIsCap: true,
+                            properties: true
+                        }
+                    ],
+                    "no-console": [
+                        "error",
+                        {
+                            allow: [
+                                "info",
+                                "warn",
+                                "error"
+                            ]
+                        }
+                    ],
+                    // https://twitter.com/ryanflorence/status/1786394911895683512
+                    "no-param-reassign": "warn",
+                    "no-restricted-syntax": [
+                        "error",
+                        ...restrictedSyntax
+                    ],
+                    "no-template-curly-in-string": "error",
+                    "no-use-before-define": [
+                        "error",
+                        {
+                            classes: false,
+                            functions: false,
+                            variables: true
+                        }
+                    ],
+                    "prefer-arrow-callback": [
+                        "error",
+                        {
+                            allowNamedFunctions: true,
+                            allowUnboundThis: true
+                        }
+                    ]
+                }
+            }
+        ]
+    ];
+}
+
+function formattingConfigs$1({ formatting }) {
+    if (!formatting) return [];
+    const jsonFormateRules = {
+        "jsonc/array-bracket-spacing": [
+            "error",
+            "never"
+        ],
+        "jsonc/comma-dangle": [
+            "error",
+            "never"
+        ],
+        "jsonc/comma-style": [
+            "error",
+            "last"
+        ],
+        "jsonc/indent": [
+            "error",
+            formatting.indent ?? 2
+        ],
+        "jsonc/key-spacing": [
+            "error",
+            {
+                afterColon: true,
+                beforeColon: false
+            }
+        ],
+        "jsonc/object-curly-spacing": [
+            "error",
+            "always"
+        ],
+        "jsonc/quote-props": "error",
+        "jsonc/quotes": "error",
+        "hyoban/jsonc-inline-spacing": "error"
+    };
+    return [
+        {
+            name: "json/json",
+            files: [
+                GLOB_JSON
+            ],
+            ignores: GLOB_SHOULD_BE_JSONC,
+            rules: {
+                ...pluginJsonc.configs["recommended-with-json"].rules,
+                ...jsonFormateRules
+            }
+        },
+        {
+            name: "json/jsonc",
+            files: [
+                GLOB_JSONC,
+                ...GLOB_SHOULD_BE_JSONC
+            ],
+            rules: {
+                ...pluginJsonc.configs["recommended-with-jsonc"].rules,
+                ...jsonFormateRules
+            }
+        },
+        {
+            name: "json/json5",
+            files: [
+                GLOB_JSON5
+            ],
+            rules: {
+                ...pluginJsonc.configs["recommended-with-json5"].rules,
+                ...jsonFormateRules
+            }
+        }
+    ];
+}
+function jsonConfigs(options) {
+    return [
+        {
+            name: "json/setup",
+            files: [
+                GLOB_JSON,
+                GLOB_JSON5,
+                GLOB_JSONC
+            ],
+            /// keep-sorted
+            plugins: {
+                "jsonc": pluginJsonc,
+                "package-json": packageJson
+            },
+            languageOptions: {
+                parser: parserJsonc
+            }
+        },
+        ...formattingConfigs$1(options),
+        packageJson.configs.recommended,
+        {
+            name: "package-json/custom",
+            files: [
+                GLOB_JSON,
+                GLOB_JSON5,
+                GLOB_JSONC
+            ],
+            rules: {
+                "package-json/order-properties": [
+                    "error",
+                    {
+                        order: [
+                            "publisher",
+                            "name",
+                            "displayName",
+                            "type",
+                            "version",
+                            "private",
+                            "packageManager",
+                            "description",
+                            "author",
+                            "contributors",
+                            "license",
+                            "funding",
+                            "homepage",
+                            "repository",
+                            "bugs",
+                            "keywords",
+                            "categories",
+                            "sideEffects",
+                            "exports",
+                            "main",
+                            "module",
+                            "unpkg",
+                            "jsdelivr",
+                            "types",
+                            "typesVersions",
+                            "bin",
+                            "icon",
+                            "files",
+                            "engines",
+                            "activationEvents",
+                            "contributes",
+                            "scripts",
+                            "release-it",
+                            "peerDependencies",
+                            "peerDependenciesMeta",
+                            "dependencies",
+                            "optionalDependencies",
+                            "devDependencies",
+                            "pnpm",
+                            "overrides",
+                            "resolutions",
+                            "husky",
+                            "simple-git-hooks",
+                            "lint-staged",
+                            "eslintConfig"
+                        ]
+                    }
+                ]
+            },
+            settings: {
+                packageJson: {
+                    enforceForPrivate: false
+                }
+            }
+        }
+    ];
+}
+
+async function interopDefault(m) {
+    const resolved = await m;
+    return resolved.default || resolved;
+}
+const severities = new Set([
+    0,
+    1,
+    2,
+    "off",
+    "warn",
+    "error"
+]);
+const defu = createDefu((obj, key, value)=>{
+    if (Array.isArray(value) && severities.has(value[0]) && Array.isArray(obj[key]) && severities.has(obj[key][0])) {
+        // @ts-expect-error It's fine here
+        obj[key] = [
+            ...value
+        ];
+        return true;
+    }
+    // use set to merge arrays
+    if (Array.isArray(value) && Array.isArray(obj[key])) {
+        // @ts-expect-error It's fine here
+        obj[key] = [
+            ...new Set([
+                ...obj[key],
+                ...value
+            ].sort())
+        ];
+        return true;
+    }
+});
+async function config(options, ...configs) {
+    const { ignoreFiles, ignores } = options;
+    const gitignore = await interopDefault(import('eslint-config-flat-gitignore'));
+    const globalIgnores = defu({
+        ignores
+    }, gitignore({
+        files: ignoreFiles,
+        strict: false
+    }));
+    return [
+        globalIgnores,
+        ...(await Promise.all(configs.map(async (c)=>{
+            if (typeof c === "function") {
+                const resolved = await c();
+                if (!resolved) return;
+                return mergeConfigs(resolved);
+            }
+            if (!c) return;
+            return mergeConfigs(c);
+        }))).filter((i)=>!!i)
+    ];
+}
+async function mergeConfigs(_c) {
+    const c = await _c;
+    if (!c) return;
+    if (Array.isArray(c)) return withFiles(defu({}, ...c.reverse()));
+    return withFiles(c);
+}
+function withFiles(config) {
+    return defu(config, "files" in config ? {} : {
+        files: GLOB_SRC
+    });
+}
+
+function excludePlugins(object) {
+    const { plugins, ...rest } = object;
+    return rest;
+}
+function reactConfigs({ react, reactCompiler, strict, typeChecked, filesDisableTypeChecking }) {
+    if (!react) return [];
+    return [
+        async ()=>{
+            const reactRefresh = await interopDefault(import('eslint-plugin-react-refresh'));
+            const reactGoogleTranslate = await interopDefault(import('eslint-plugin-react-google-translate'));
+            const eslintReact = await interopDefault(import('@eslint-react/eslint-plugin'));
+            const config = strict ? eslintReact.configs.strict : eslintReact.configs.recommended;
+            const reactHooks = await interopDefault(import('eslint-plugin-react-hooks'));
+            return {
+                name: `react/setup/${strict ? "strict" : "recommended"}`,
+                plugins: {
+                    "react-refresh": reactRefresh,
+                    "react-google-translate": reactGoogleTranslate,
+                    "react-hooks": reactHooks,
+                    // @ts-expect-error type error
+                    ...config.plugins
+                }
+            };
+        },
+        async ()=>{
+            const eslintReact = await interopDefault(import('@eslint-react/eslint-plugin'));
+            const config = strict ? eslintReact.configs.strict : eslintReact.configs.recommended;
+            return {
+                ...excludePlugins(config),
+                name: `react/${strict ? "strict" : "recommended"}`,
+                files: GLOB_TS_SRC
+            };
+        },
+        ()=>{
+            if (strict) {
+                return {
+                    name: "react/all/custom",
+                    files: GLOB_TS_SRC,
+                    rules: {
+                        "@eslint-react/naming-convention/filename": "off",
+                        "@eslint-react/naming-convention/use-state": "off",
+                        "@eslint-react/avoid-shorthand-boolean": "off",
+                        "@eslint-react/avoid-shorthand-fragment": "off",
+                        "@eslint-react/prefer-namespace-import": "warn"
+                    }
+                };
+            }
+            return {
+                name: "react/recommended/custom",
+                files: GLOB_TS_SRC,
+                rules: {
+                    "@eslint-react/no-unstable-context-value": "warn",
+                    "@eslint-react/dom/no-dangerously-set-innerhtml": "off",
+                    "@eslint-react/naming-convention/use-state": "off",
+                    // https://github.com/jsx-eslint/eslint-plugin-react/issues/2628#issuecomment-984160944
+                    // {
+                    //   selector: 'ImportDeclaration[source.value=\'react\'][specifiers.0.type=\'ImportDefaultSpecifier\']',
+                    //   message: 'Default React import not allowed, use import * as React from \'react\'',
+                    // },
+                    "@eslint-react/prefer-namespace-import": "warn"
+                }
+            };
+        },
+        ()=>{
+            if (!typeChecked) return;
+            return {
+                name: "react/type-checked",
+                files: GLOB_TS_SRC,
+                ignores: filesDisableTypeChecking.length > 0 ? filesDisableTypeChecking : undefined,
+                rules: {
+                    "@eslint-react/no-leaked-conditional-rendering": "error"
+                }
+            };
+        },
+        ()=>{
+            return {
+                name: "react/official",
+                files: GLOB_TS_SRC,
+                rules: {
+                    // Core hooks rules
+                    "react-hooks/rules-of-hooks": "error",
+                    "react-hooks/exhaustive-deps": "warn",
+                    ...reactCompiler ? {
+                        // React Compiler rules
+                        "react-hooks/config": "error",
+                        "react-hooks/error-boundaries": "error",
+                        "react-hooks/component-hook-factories": "error",
+                        "react-hooks/gating": "error",
+                        "react-hooks/globals": "error",
+                        "react-hooks/immutability": "error",
+                        "react-hooks/preserve-manual-memoization": "error",
+                        "react-hooks/purity": "error",
+                        "react-hooks/refs": "error",
+                        "react-hooks/set-state-in-effect": "error",
+                        "react-hooks/set-state-in-render": "error",
+                        "react-hooks/static-components": "error",
+                        "react-hooks/unsupported-syntax": "warn",
+                        "react-hooks/use-memo": "error",
+                        "react-hooks/incompatible-library": "warn"
+                    } : {}
+                }
+            };
+        },
+        {
+            name: "react/refresh",
+            files: GLOB_JSX_SRC,
+            rules: {
+                "react-refresh/only-export-components": [
+                    "warn",
+                    {
+                        allowConstantExport: react === "vite",
+                        allowExportNames: react === "next" ? [
+                            "config",
+                            "generateStaticParams",
+                            "metadata",
+                            "generateMetadata",
+                            "viewport",
+                            "generateViewport",
+                            "dynamic"
+                        ] : react === "remix" ? [
+                            "meta",
+                            "links",
+                            "headers",
+                            "loader",
+                            "action"
+                        ] : react === "expo" ? [
+                            "unstable_settings"
+                        ] : undefined
+                    }
+                ]
+            }
+        },
+        {
+            name: "react/google-translate",
+            files: GLOB_JSX_SRC,
+            rules: {
+                "react-google-translate/no-conditional-text-nodes-with-siblings": "warn",
+                "react-google-translate/no-return-text-nodes": "warn"
+            }
+        }
+    ];
+}
+
+function regexConfig() {
+    return [
+        regexpPlugin.configs["flat/recommended"],
+        {
+            name: "regexp/recommended"
+        }
+    ];
+}
+
+function formattingConfigs({ formatting, lessOpinionated }) {
+    if (!formatting) {
+        return [];
+    }
+    const jsxIgnoreNodes = [
+        "TemplateLiteral *",
+        "TSUnionType",
+        "TSIntersectionType",
+        "TSTypeParameterInstantiation",
+        "FunctionExpression > .params[decorators.length > 0]",
+        "FunctionExpression > .params > :matches(Decorator, :not(:first-child))"
+    ];
+    const nonJsxIgnoreNodes = [
+        "JSXOpeningElement",
+        "JSXClosingElement"
+    ];
+    const basicIndentRuleOptions = {
+        ArrayExpression: 1,
+        CallExpression: {
+            arguments: 1
+        },
+        flatTernaryExpressions: false,
+        FunctionDeclaration: {
+            body: 1,
+            parameters: 1
+        },
+        FunctionExpression: {
+            body: 1,
+            parameters: 1
+        },
+        ignoreComments: false,
+        ImportDeclaration: 1,
+        MemberExpression: 1,
+        ObjectExpression: 1,
+        offsetTernaryExpressions: true,
+        outerIIFEBody: 1,
+        SwitchCase: 1,
+        VariableDeclarator: 1
+    };
+    return [
+        {
+            name: "@stylistic/shared",
+            files: undefined,
+            ...pluginStylistic.configs.customize(formatting)
+        },
+        {
+            name: "@stylistic/customize",
+            files: undefined,
+            plugins: {
+                "antfu": pluginAntfu,
+                "hyoban": pluginHyoban,
+                "@stylistic": pluginStylistic
+            },
+            rules: {
+                "@stylistic/quotes": [
+                    "error",
+                    formatting.quotes,
+                    {
+                        allowTemplateLiterals: "always",
+                        avoidEscape: true
+                    }
+                ],
+                "@stylistic/max-statements-per-line": "off",
+                "@stylistic/multiline-ternary": [
+                    "error",
+                    "always-multiline",
+                    {
+                        ignoreJSX: true
+                    }
+                ],
+                "@stylistic/operator-linebreak": [
+                    "error",
+                    formatting.lineBreak ?? "before"
+                ],
+                "@stylistic/jsx-one-expression-per-line": [
+                    "error",
+                    {
+                        allow: "single-line"
+                    }
+                ],
+                "antfu/consistent-chaining": "error",
+                "antfu/consistent-list-newline": "error",
+                "hyoban/jsx-attribute-spacing": "error",
+                "@stylistic/no-tabs": "off",
+                "@stylistic/jsx-indent-props": "off",
+                "@stylistic/indent": [
+                    "error",
+                    formatting.indent,
+                    {
+                        ...basicIndentRuleOptions,
+                        ignoredNodes: [
+                            ...jsxIgnoreNodes,
+                            ...nonJsxIgnoreNodes
+                        ]
+                    }
+                ],
+                ...lessOpinionated ? {
+                    curly: [
+                        "error",
+                        "multi-line",
+                        "consistent"
+                    ]
+                } : {
+                    "antfu/curly": "error",
+                    "antfu/if-newline": "error"
+                }
+            }
+        },
+        {
+            files: GLOB_JSX_SRC,
+            rules: {
+                "@stylistic/indent": [
+                    "error",
+                    formatting.indent,
+                    {
+                        ...basicIndentRuleOptions,
+                        ignoredNodes: jsxIgnoreNodes
+                    }
+                ]
+            }
+        }
+    ];
+}
+function stylisticConfigs(options) {
+    const { typeChecked, lessOpinionated } = options;
+    return [
+        ...formattingConfigs(options),
+        typeChecked === true ? typescriptEslint.configs.stylisticTypeChecked : typescriptEslint.configs.stylistic,
+        {
+            name: "typescript-eslint/stylistic/custom",
+            files: GLOB_TS_SRC,
+            rules: {
+                "@typescript-eslint/no-empty-function": "off",
+                "@typescript-eslint/consistent-type-definitions": "off",
+                ...lessOpinionated ? {
+                    "@typescript-eslint/array-type": "off"
+                } : {
+                    "@typescript-eslint/array-type": [
+                        "error",
+                        {
+                            default: "array-simple"
+                        }
+                    ]
+                }
+            }
+        },
+        typeChecked && {
+            name: "typescript-eslint/stylistic-type-checked/custom",
+            files: GLOB_TS_SRC,
+            rules: {
+                "@typescript-eslint/prefer-nullish-coalescing": "off"
+            }
+        },
+        {
+            name: "@stylistic/customize",
+            files: undefined,
+            plugins: {
+                "antfu": pluginAntfu,
+                "hyoban": pluginHyoban,
+                "@stylistic": pluginStylistic
+            },
+            rules: {
+                "object-shorthand": "error",
+                "prefer-destructuring": [
+                    "error",
+                    {
+                        VariableDeclarator: {
+                            array: false,
+                            object: true
+                        },
+                        AssignmentExpression: {
+                            array: false,
+                            object: false
+                        }
+                    },
+                    {
+                        enforceForRenamedProperties: false
+                    }
+                ],
+                "prefer-template": "error",
+                "@stylistic/jsx-self-closing-comp": [
+                    "error",
+                    {
+                        component: true,
+                        html: true
+                    }
+                ],
+                ...lessOpinionated ? {} : {
+                    "antfu/top-level-function": "error",
+                    "hyoban/prefer-early-return": "error"
+                }
+            }
+        }
+    ];
+}
+
+function tailwindCSSConfig({ tailwindCSS }) {
+    if (!tailwindCSS) return;
+    process.env.TAILWIND_MODE = "build";
+    return async ()=>{
+        const tailwind = await interopDefault(import('eslint-plugin-tailwindcss'));
+        return [
+            ...tailwind.configs["flat/recommended"],
+            {
+                name: "tailwindcss/recommended",
+                files: GLOB_TS_SRC
+            },
+            typeof tailwindCSS === "object" && !tailwindCSS.order && {
+                rules: {
+                    "tailwindcss/classnames-order": "off"
+                }
+            }
+        ];
+    };
+}
+
+function typeScriptConfigs({ strict, typeChecked, project, projectService, tsconfigRootDir, filesDisableTypeChecking, preferESM }) {
+    const typescriptPreset = strict ? typeChecked === true ? typescriptEslint.configs.strictTypeChecked : typescriptEslint.configs.strict : typeChecked === true ? typescriptEslint.configs.recommendedTypeChecked : typescriptEslint.configs.recommended;
+    return [
+        typescriptEslint.configs.base,
+        [
+            ...typescriptPreset,
+            typeChecked && {
+                languageOptions: {
+                    parserOptions: {
+                        project,
+                        projectService,
+                        tsconfigRootDir
+                    }
+                }
+            }
+        ],
+        [
+            {
+                name: "typescript-eslint/custom",
+                files: GLOB_TS_SRC,
+                rules: {
+                    "no-use-before-define": "off",
+                    "@typescript-eslint/consistent-type-imports": [
+                        "error",
+                        {
+                            disallowTypeAnnotations: false
+                        }
+                    ],
+                    "@typescript-eslint/no-import-type-side-effects": "error",
+                    // https://www.totaltypescript.com/method-shorthand-syntax-considered-harmful
+                    "@typescript-eslint/method-signature-style": [
+                        "error",
+                        "property"
+                    ],
+                    "@typescript-eslint/no-unused-expressions": [
+                        "error",
+                        {
+                            allowShortCircuit: true,
+                            allowTernary: true
+                        }
+                    ],
+                    "@typescript-eslint/no-dynamic-delete": "off",
+                    "@typescript-eslint/no-empty-object-type": [
+                        "error",
+                        {
+                            allowInterfaces: "with-single-extends",
+                            allowObjectTypes: "never",
+                            allowWithName: "Props$"
+                        }
+                    ]
+                }
+            },
+            strict ? {
+                rules: {
+                    "@typescript-eslint/no-non-null-assertion": "off"
+                }
+            } : {
+                rules: {
+                    "@typescript-eslint/ban-ts-comment": "off",
+                    "@typescript-eslint/no-explicit-any": "off",
+                    "@typescript-eslint/no-non-null-asserted-optional-chain": "warn"
+                }
+            },
+            !preferESM && {
+                rules: {
+                    "@typescript-eslint/no-require-imports": "off"
+                }
+            },
+            typeChecked && (typeChecked === "essential" ? {
+                rules: {
+                    // https://youtu.be/OVNQWzdhCQA?si=PvPOOgtGW5H4uRB7
+                    "@typescript-eslint/await-thenable": "error",
+                    "@typescript-eslint/no-floating-promises": "error",
+                    "@typescript-eslint/no-misused-promises": [
+                        "error",
+                        {
+                            checksVoidReturn: {
+                                arguments: false,
+                                attributes: false
+                            }
+                        }
+                    ]
+                }
+            } : {
+                rules: {
+                    "@typescript-eslint/consistent-type-exports": "error",
+                    "@typescript-eslint/no-misused-promises": [
+                        "error",
+                        {
+                            checksVoidReturn: {
+                                arguments: false,
+                                attributes: false
+                            }
+                        }
+                    ],
+                    "@typescript-eslint/restrict-template-expressions": [
+                        "error",
+                        {}
+                    ],
+                    "@typescript-eslint/no-deprecated": "warn"
+                }
+            })
+        ],
+        ()=>{
+            if (filesDisableTypeChecking.length === 0) return;
+            return {
+                files: filesDisableTypeChecking,
+                ...typescriptEslint.configs.disableTypeChecked
+            };
+        }
+    ];
+}
+
+function unicornConfigs({ fileCase, preferESM }) {
+    return [
+        pluginUnicorn.configs.unopinionated,
+        {
+            name: "unicorn/custom",
+            rules: {
+                "unicorn/filename-case": fileCase ? [
+                    "error",
+                    {
+                        case: fileCase
+                    }
+                ] : "off",
+                "unicorn/prefer-module": preferESM ? "error" : "off",
+                // https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1109#issuecomment-782689255
+                "unicorn/consistent-destructuring": "off",
+                // https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2341
+                "unicorn/escape-case": "off",
+                "unicorn/no-hex-escape": "off",
+                // Buggy
+                "unicorn/custom-error-definition": "off",
+                "unicorn/consistent-function-scoping": "off",
+                // Annoying
+                "unicorn/no-keyword-prefix": "off",
+                "unicorn/prefer-global-this": "off",
+                "unicorn/catch-error-name": "off",
+                "unicorn/import-style": "off",
+                "unicorn/no-array-for-each": "off",
+                "unicorn/no-array-reduce": "off",
+                "unicorn/no-await-expression-member": "off",
+                "unicorn/no-negated-condition": "off",
+                "unicorn/no-nested-ternary": "off",
+                // https://github.com/sindresorhus/meta/discussions/7
+                "unicorn/no-null": "off",
+                "unicorn/no-unreadable-array-destructuring": "off",
+                "unicorn/numeric-separators-style": "off",
+                "unicorn/prefer-spread": "off",
+                "unicorn/prefer-string-raw": "off",
+                // https://github.com/orgs/web-infra-dev/discussions/10
+                "unicorn/prefer-top-level-await": "off",
+                "unicorn/prevent-abbreviations": "off",
+                // this is common in config files
+                "unicorn/no-anonymous-default-export": "off",
+                "unicorn/no-array-sort": "off",
+                "unicorn/no-array-reverse": "off",
+                "unicorn/text-encoding-identifier-case": "off",
+                "unicorn/prefer-ternary": "off",
+                "unicorn/prefer-add-event-listener": "off",
+                "unicorn/number-literal-case": "off",
+                "unicorn/prefer-math-trunc": "off"
+            }
+        }
+    ];
+}
+
+function unocssConfig({ unocss }) {
+    if (!unocss) return;
+    return async ()=>{
+        const unocss = await interopDefault(import('@unocss/eslint-config/flat'));
+        return unocss;
+    };
+}
+
+function unusedConfig() {
+    return {
+        name: "extend/unused",
+        plugins: {
+            "unused-imports": pluginUnusedImports
+        },
+        rules: {
+            "no-unused-vars": "off",
+            "@typescript-eslint/no-unused-vars": "off",
+            "unused-imports/no-unused-imports": "error",
+            "unused-imports/no-unused-vars": [
+                "error",
+                {
+                    args: "after-used",
+                    argsIgnorePattern: "^_",
+                    ignoreRestSiblings: true,
+                    vars: "all",
+                    varsIgnorePattern: "^_"
+                }
+            ]
+        }
+    };
+}
+
+async function mergeDefaultOptions(options) {
+    const packageJson = await readPackageUp();
+    const hasReact = isPackageExists("react");
+    const hasVite = isPackageExists("vite");
+    const hasRemix = isPackageExists("remix");
+    const hasNext = isPackageExists("next");
+    const hasExpo = isPackageExists("expo");
+    const hasUnocss = isPackageExists("unocss");
+    const tailwindPackageInfo = await getPackageInfo("tailwindcss");
+    const hasTailwindCSS = !!tailwindPackageInfo?.version;
+    /// keep-sorted
+    const defaultOptions = {
+        fileCase: false,
+        filesDisableTypeChecking: [],
+        formatting: {
+            indent: 2,
+            quotes: "double",
+            semi: true
+        },
+        ignoreFiles: DEFAULT_IGNORE_FILES,
+        ignores: GLOB_EXCLUDE,
+        lessOpinionated: false,
+        linterOptions: {
+            reportUnusedDisableDirectives: true
+        },
+        preferESM: packageJson?.packageJson.type === "module",
+        project: !!options?.typeChecked,
+        projectService: false,
+        react: hasNext ? "next" : hasRemix ? "remix" : hasExpo ? "expo" : hasVite && hasReact ? "vite" : hasReact,
+        reactCompiler: false,
+        restrictedSyntax: [
+            "DebuggerStatement",
+            "LabeledStatement",
+            "WithStatement",
+            // https://www.typescriptlang.org/docs/handbook/enums.html#const-enums
+            // https://youtu.be/XTXPKbPcvl4?si=J_2E9dM25sAEXM2x
+            "TSEnumDeclaration[const=true]",
+            "TSExportAssignment"
+        ],
+        settings: {
+            ...hasTailwindCSS ? {
+                tailwindcss: {
+                    callees: [
+                        "classnames",
+                        "clsx",
+                        "ctl",
+                        "cn"
+                    ]
+                }
+            } : {}
+        },
+        strict: false,
+        tailwindCSS: hasTailwindCSS,
+        tsconfigRootDir: process.cwd(),
+        typeChecked: false,
+        unocss: hasUnocss
+    };
+    return defu$1(options, defaultOptions);
+}
+
+async function defineConfig(options, ...args) {
+    const finalOptions = await mergeDefaultOptions(options);
+    return config(finalOptions, ...javaScriptConfigs(finalOptions), ...unicornConfigs(finalOptions), ...typeScriptConfigs(finalOptions), importConfig(), unusedConfig(), regexConfig(), commandConfig(), ...stylisticConfigs(finalOptions), ...jsonConfigs(finalOptions), ...reactConfigs(finalOptions), tailwindCSSConfig(finalOptions), unocssConfig(finalOptions), ...args);
+}
+
+export { DEFAULT_IGNORE_FILES, GLOB_EXCLUDE, GLOB_JSON, GLOB_JSON5, GLOB_JSONC, GLOB_JSON_SRC, GLOB_JSX_SRC, GLOB_JS_SRC, GLOB_SHOULD_BE_JSONC, GLOB_SRC, GLOB_TS_SRC, defineConfig };