@solvro/config 2.0.4 → 2.0.6

package/dist/eslint/index.cjs

@@ -0,0 +1,1230 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/eslint/plugins.ts
+var import_eslint_plugin_eslint_comments, import_eslint_plugin_antfu, import_eslint_plugin_import, import_eslint_plugin_n, import_eslint_plugin_unicorn, import_eslint_plugin_unused_imports;
+var init_plugins = __esm({
+  "src/eslint/plugins.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_eslint_plugin_eslint_comments = __toESM(require("@eslint-community/eslint-plugin-eslint-comments"), 1);
+    import_eslint_plugin_antfu = __toESM(require("eslint-plugin-antfu"), 1);
+    import_eslint_plugin_import = __toESM(require("eslint-plugin-import"), 1);
+    import_eslint_plugin_n = __toESM(require("eslint-plugin-n"), 1);
+    import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
+    import_eslint_plugin_unused_imports = __toESM(require("eslint-plugin-unused-imports"), 1);
+  }
+});
+
+// src/eslint/configs/imports.ts
+function imports({
+  forbidDefaultExport = true
+} = {}) {
+  const config = [
+    import_eslint_plugin_import.default.flatConfigs.typescript,
+    {
+      name: "solvro/imports/rules",
+      plugins: {
+        antfu: import_eslint_plugin_antfu.default
+      },
+      rules: {
+        "antfu/import-dedupe": "error",
+        "antfu/no-import-dist": "error",
+        "antfu/no-import-node-modules-by-path": "error",
+        ...import_eslint_plugin_import.default.flatConfigs.recommended.rules,
+        "import/no-dynamic-require": "warn",
+        "import/no-unresolved": "off",
+        "import/consistent-type-specifier-style": "warn",
+        "@typescript-eslint/no-restricted-imports": [
+          "error",
+          {
+            paths: [
+              {
+                name: "axios",
+                message: "Please use fetch instead"
+              },
+              ...forbiddenUiLibraries.map((library) => ({
+                name: library,
+                message: `Please use ui.shadcn.com components instead.`
+              }))
+            ]
+          }
+        ]
+      }
+    }
+  ];
+  if (forbidDefaultExport) {
+    config.push(
+      {
+        rules: { "import/no-default-export": "error" }
+      },
+      {
+        files: [
+          "tsup.config.*",
+          "eslint.config.*",
+          ".commitlintrc.*",
+          "knip.*",
+          "next.config.*",
+          "commitlint.config.*",
+          "vite.config.*",
+          ".releaserc.*",
+          "vitest.config.*",
+          "postcss.config.*",
+          "playwright.config.*"
+        ],
+        rules: {
+          "import/no-default-export": "off"
+        }
+      }
+    );
+  }
+  return config;
+}
+var forbiddenUiLibraries;
+var init_imports = __esm({
+  "src/eslint/configs/imports.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_plugins();
+    forbiddenUiLibraries = [
+      "@headlessui/react",
+      "@mui/material",
+      "@chakra-ui/react",
+      "@chakra-ui/core",
+      "@nextui-org/react",
+      "react-bootstrap",
+      "antd"
+    ];
+  }
+});
+
+// src/eslint/configs/node.ts
+function node() {
+  return [
+    {
+      name: "solvro/node/rules",
+      plugins: {
+        node: import_eslint_plugin_n.default
+      },
+      rules: {
+        "node/handle-callback-err": ["error", "^(err|error)$"],
+        "node/no-deprecated-api": "error",
+        "node/no-exports-assign": "error",
+        "node/no-new-require": "error",
+        "node/no-path-concat": "error",
+        "node/prefer-global/buffer": ["error"],
+        "node/prefer-global/process": ["error"],
+        "node/process-exit-as-throw": "error"
+      }
+    }
+  ];
+}
+var init_node = __esm({
+  "src/eslint/configs/node.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_plugins();
+  }
+});
+
+// src/eslint/presets/adonis.ts
+var adonis_exports = {};
+__export(adonis_exports, {
+  adonisPreset: () => adonisPreset
+});
+var import_eslint_config, adonisPreset;
+var init_adonis = __esm({
+  "src/eslint/presets/adonis.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_eslint_config = require("@adonisjs/eslint-config");
+    init_imports();
+    init_node();
+    adonisPreset = () => {
+      const builtinAdonisConfig = (0, import_eslint_config.configApp)();
+      return [
+        ...builtinAdonisConfig,
+        ...node(),
+        ...imports(),
+        {
+          rules: {
+            "@typescript-eslint/naming-convention": [
+              "error",
+              {
+                selector: ["enum", "enumMember", "class", "interface", "typeLike"],
+                format: ["PascalCase"],
+                leadingUnderscore: "allow",
+                trailingUnderscore: "allow"
+              },
+              {
+                selector: [
+                  "classProperty",
+                  "classMethod",
+                  "method",
+                  "variableLike"
+                ],
+                format: ["camelCase"],
+                leadingUnderscore: "allow",
+                trailingUnderscore: "allow"
+              },
+              {
+                selector: "variable",
+                format: ["camelCase", "UPPER_CASE", "PascalCase"],
+                leadingUnderscore: "allow",
+                trailingUnderscore: "allow"
+              }
+            ]
+          }
+        }
+      ];
+    };
+  }
+});
+
+// src/eslint/configs/typescript-strict.ts
+function typescriptStrict() {
+  return [
+    ...import_typescript_eslint3.default.configs.strictTypeChecked,
+    ...import_typescript_eslint3.default.configs.stylisticTypeChecked,
+    {
+      name: "solvro/typescript-strict/setup",
+      plugins: {
+        antfu: import_eslint_plugin_antfu.default
+      }
+    },
+    {
+      files: ["**/*.{ts,tsx}"],
+      name: "solvro/typescript-strict/rules",
+      rules: {
+        "@typescript-eslint/ban-ts-comment": [
+          "error",
+          { "ts-expect-error": "allow-with-description" }
+        ],
+        "@typescript-eslint/consistent-type-definitions": [
+          "error",
+          "interface"
+        ],
+        "@typescript-eslint/consistent-type-imports": [
+          "error",
+          {
+            disallowTypeAnnotations: false,
+            prefer: "type-imports"
+          }
+        ],
+        "@typescript-eslint/method-signature-style": ["error", "property"],
+        // https://www.totaltypescript.com/method-shorthand-syntax-considered-harmful
+        "@typescript-eslint/no-dupe-class-members": "error",
+        "@typescript-eslint/no-empty-object-type": [
+          "error",
+          { allowInterfaces: "always" }
+        ],
+        "@typescript-eslint/no-import-type-side-effects": "error",
+        "@typescript-eslint/no-redeclare": ["error", { builtinGlobals: false }],
+        "@typescript-eslint/no-require-imports": "error",
+        "@typescript-eslint/no-unused-expressions": [
+          "error",
+          {
+            allowShortCircuit: true,
+            allowTaggedTemplates: true,
+            allowTernary: true
+          }
+        ],
+        "@typescript-eslint/no-use-before-define": [
+          "error",
+          { classes: false, functions: false, variables: true }
+        ],
+        "@typescript-eslint/no-wrapper-object-types": "error",
+        // prevent unnecessary use of void operator
+        "@typescript-eslint/no-meaningless-void-operator": "error",
+        // "using non-null assertions cancels the benefits of the strict
+        // null-checking mode."
+        // warn when one of the types in union / intersection overrides others
+        "@typescript-eslint/no-redundant-type-constituents": "warn",
+        // prevent variables shadowing
+        "no-shadow": "error",
+        "@typescript-eslint/no-shadow": "error",
+        // prevent assignment of this, signals a wrong usage of it
+        "@typescript-eslint/no-this-alias": "error",
+        // prevent throwing non-error
+        "no-throw-literal": "off",
+        // prevent unnecessary explicitly adding a default type argument
+        "@typescript-eslint/no-unnecessary-type-arguments": "error",
+        // prevent unnecessary assertions that won't change the outcome
+        "@typescript-eslint/no-unnecessary-type-assertion": "error",
+        // prevent extending default types
+        "@typescript-eslint/no-unnecessary-type-constraint": "error",
+        // force typing out function arguments
+        "@typescript-eslint/no-unsafe-argument": "error",
+        // prevent usage of any via reassigning
+        "@typescript-eslint/no-unsafe-assignment": "error",
+        // prevent usage of any via calling it
+        "@typescript-eslint/no-unsafe-call": "error",
+        // prevent usage of any via using it's members
+        "@typescript-eslint/no-unsafe-member-access": "error",
+        // prevent reverting any from functions
+        "@typescript-eslint/no-unsafe-return": "error",
+        // prevent unused expressions
+        "no-unused-expressions": "off",
+        // var<'string'> = 'string' -> var = 'string' as const
+        "@typescript-eslint/prefer-as-const": "error",
+        // force initializing enums
+        "@typescript-eslint/prefer-enum-initializers": "error",
+        // prefer for x of obj to for let i = 0...
+        "@typescript-eslint/prefer-for-of": "error",
+        // prefer includes() to indexOf()
+        "@typescript-eslint/prefer-includes": "error",
+        // use literals for enum initialization
+        "@typescript-eslint/prefer-literal-enum-member": "error",
+        // prefer safe cascade of a value when dealing with undefined or null
+        "@typescript-eslint/prefer-nullish-coalescing": "error",
+        // prefer optional chaining (a?.b)
+        "@typescript-eslint/prefer-optional-chain": "error",
+        // prefer using type parameter for Array.reduce
+        "@typescript-eslint/prefer-reduce-type-parameter": "error",
+        // prefer RegExp#exec when no /g flag in regex
+        "@typescript-eslint/prefer-regexp-exec": "error",
+        // enforce `this` as a type when stating type for a method
+        "@typescript-eslint/prefer-return-this-type": "error",
+        // enforce startsWith to indexOf === 0
+        "@typescript-eslint/prefer-string-starts-ends-with": "error",
+        // prevents default behavior of .sort() - which is confusing
+        "@typescript-eslint/require-array-sort-compare": "error",
+        // no async functions without awaits in body
+        "require-await": "off",
+        "@typescript-eslint/require-await": "error",
+        // prevent number + string
+        "@typescript-eslint/restrict-plus-operands": "error",
+        // only allow string in templates
+        "@typescript-eslint/restrict-template-expressions": "error",
+        // prevent returning await
+        "no-return-await": "off",
+        "@typescript-eslint/return-await": "error",
+        // only booleans in ifs and whiles
+        "@typescript-eslint/strict-boolean-expressions": "error",
+        // check if all paths are followed in code
+        "@typescript-eslint/switch-exhaustiveness-check": "error",
+        "dot-notation": "off",
+        "no-implied-eval": "off",
+        "@typescript-eslint/await-thenable": "error",
+        "@typescript-eslint/dot-notation": ["error", { allowKeywords: true }],
+        "@typescript-eslint/no-floating-promises": "error",
+        "@typescript-eslint/no-for-in-array": "error",
+        "@typescript-eslint/no-implied-eval": "error",
+        "@typescript-eslint/no-misused-promises": "error",
+        "@typescript-eslint/promise-function-async": "error",
+        "@typescript-eslint/unbound-method": "error",
+        "no-restricted-imports": "off"
+      }
+    }
+  ];
+}
+var import_typescript_eslint3;
+var init_typescript_strict = __esm({
+  "src/eslint/configs/typescript-strict.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_typescript_eslint3 = __toESM(require("typescript-eslint"), 1);
+    init_plugins();
+  }
+});
+
+// src/eslint/configs/unicorn.ts
+function unicorn() {
+  return [
+    {
+      name: "solvro/unicorn/rules",
+      plugins: {
+        unicorn: import_eslint_plugin_unicorn.default
+      },
+      rules: {
+        ...import_eslint_plugin_unicorn.default.configs.recommended.rules,
+        "unicorn/no-array-reduce": "off",
+        "unicorn/no-null": "off",
+        "unicorn/no-useless-switch-case": "off",
+        "unicorn/prefer-global-this": "off",
+        "unicorn/prevent-abbreviations": [
+          "error",
+          {
+            replacements: {
+              env: false,
+              envs: false,
+              props: false,
+              prop: false,
+              ref: false,
+              utils: false
+            },
+            allowList: {
+              e2e: true
+            },
+            ignore: [String.raw`e2e`]
+          }
+        ]
+      }
+    }
+  ];
+}
+var init_unicorn = __esm({
+  "src/eslint/configs/unicorn.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_plugins();
+  }
+});
+
+// src/eslint/presets/nestjs.ts
+var nestjs_exports = {};
+__export(nestjs_exports, {
+  nestjsPreset: () => nestjsPreset
+});
+var import_eslint_plugin_nestjs_typed, import_local_pkg, nestjsPreset;
+var init_nestjs = __esm({
+  "src/eslint/presets/nestjs.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_eslint_plugin_nestjs_typed = __toESM(require("@darraghor/eslint-plugin-nestjs-typed"), 1);
+    import_local_pkg = require("local-pkg");
+    init_imports();
+    init_node();
+    init_typescript_strict();
+    init_unicorn();
+    nestjsPreset = async () => {
+      const hasSwagger = await (0, import_local_pkg.isPackageListed)("@nestjs/swagger");
+      const nestjsConfig = hasSwagger ? [
+        ...import_eslint_plugin_nestjs_typed.default.configs.flatRecommended,
+        {
+          rules: {
+            "@darraghor/nestjs-typed/api-property-matches-property-optionality": "warn",
+            "@darraghor/nestjs-typed/controllers-should-supply-api-tags": "warn",
+            "@darraghor/nestjs-typed/api-method-should-specify-api-response": "warn",
+            "@darraghor/nestjs-typed/api-method-should-specify-api-operation": "warn",
+            "@darraghor/nestjs-typed/api-enum-property-best-practices": "warn",
+            "@darraghor/nestjs-typed/api-property-returning-array-should-set-array": "warn"
+          }
+        }
+      ] : import_eslint_plugin_nestjs_typed.default.configs.flatNoSwagger;
+      return [
+        ...node(),
+        ...unicorn(),
+        ...typescriptStrict(),
+        ...imports({ forbidDefaultExport: true }),
+        ...nestjsConfig,
+        {
+          rules: {
+            "no-implicit-coercion": [
+              "error",
+              {
+                allow: ["+"]
+              }
+            ],
+            "unicorn/prefer-top-level-await": "off",
+            // flaky as hell
+            "@darraghor/nestjs-typed/injectable-should-be-provided": "off"
+          }
+        },
+        {
+          rules: {
+            "@typescript-eslint/no-extraneous-class": [
+              "error",
+              {
+                allowEmpty: true
+              }
+            ]
+          },
+          files: ["**/*.module.ts"]
+        },
+        {
+          rules: {
+            "@typescript-eslint/no-floating-promises": "off"
+          },
+          files: ["./src/main.ts"]
+        }
+      ];
+    };
+  }
+});
+
+// src/eslint/configs/a11y.ts
+function a11y() {
+  return [
+    {
+      files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+      ...import_eslint_plugin_jsx_a11y.default.flatConfigs.recommended,
+      languageOptions: {
+        ...import_eslint_plugin_jsx_a11y.default.flatConfigs.recommended.languageOptions,
+        globals: {
+          ...import_globals2.default.serviceworker,
+          ...import_globals2.default.browser
+        }
+      },
+      settings: {
+        "jsx-a11y": {
+          components: {
+            Input: "input",
+            Button: "button",
+            Link: "a",
+            Label: "label",
+            Select: "select",
+            Textarea: "textarea"
+          },
+          attributes: {
+            for: ["htmlFor", "for"]
+          }
+        }
+      }
+    }
+  ];
+}
+var import_eslint_plugin_jsx_a11y, import_globals2;
+var init_a11y = __esm({
+  "src/eslint/configs/a11y.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_eslint_plugin_jsx_a11y = __toESM(require("eslint-plugin-jsx-a11y"), 1);
+    import_globals2 = __toESM(require("globals"), 1);
+  }
+});
+
+// src/eslint/configs/react.ts
+async function react() {
+  const isUsingNext = nextJsPackages.some(
+    (index) => (0, import_local_pkg2.isPackageListedSync)(index)
+  );
+  const isUsingVite = vitePackages.some((index) => (0, import_local_pkg2.isPackageListedSync)(index));
+  const nextjsConfig = [];
+  if (isUsingNext) {
+    const nextPlugin = await import("@next/eslint-plugin-next").then(
+      (d) => d.default
+    );
+    nextjsConfig.push(
+      {
+        name: "solvro/next/setup",
+        plugins: {
+          "@next/next": nextPlugin
+        },
+        rules: nextPlugin.configs.recommended.rules
+      },
+      {
+        files: [
+          "**/app/**/{page,loading,layout,template,error,not-found,unauthorized,forbidden,default,robots,sitemap}.{js,jsx,ts,tsx}",
+          "**/pages/**/*.{js,jsx,ts,tsx}"
+        ],
+        name: "solvro/next/pages",
+        rules: {
+          "import/no-default-export": "off"
+        }
+      }
+    );
+  }
+  const viteConfig = [];
+  if (isUsingVite) {
+    viteConfig.push(import_eslint_plugin_react_refresh.default.configs.vite);
+  }
+  return [
+    {
+      name: "solvro/react/setup",
+      plugins: {
+        react: import_eslint_plugin_react.default,
+        "react-hooks": import_eslint_plugin_react_hooks.default
+      }
+    },
+    ...nextjsConfig,
+    ...viteConfig,
+    {
+      files: ["**/*.{js,jsx,mjs,cjs,ts,tsx}"],
+      languageOptions: {
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          }
+        },
+        sourceType: "module"
+      },
+      settings: {
+        react: {
+          version: "detect"
+        }
+      },
+      name: "solvro/react/rules",
+      rules: {
+        ...import_eslint_plugin_react.default.configs.flat.recommended.rules,
+        ...import_eslint_plugin_react.default.configs.flat["jsx-runtime"].rules,
+        "react/no-danger": "warn",
+        "react/jsx-no-leaked-render": "warn",
+        // recommended rules react-hooks
+        "react-hooks/exhaustive-deps": "warn",
+        "react-hooks/rules-of-hooks": "error",
+        "react/jsx-no-useless-fragment": "error",
+        "react/function-component-definition": [
+          "error",
+          {
+            unnamedComponents: "arrow-function",
+            namedComponents: "function-declaration"
+          }
+        ],
+        "react/hook-use-state": [
+          "error",
+          {
+            allowDestructuredState: true
+          }
+        ],
+        "react/no-array-index-key": "warn"
+      }
+    },
+    ...import_eslint_plugin_query.default.configs["flat/recommended"],
+    import_eslint_plugin_react_you_might_not_need_an_effect.default.configs.recommended,
+    {
+      name: "solvro/react/disables",
+      files: ["**/components/ui/*.{jsx,tsx}"],
+      rules: {
+        "react/prop-types": "off",
+        "no-shadow": "off",
+        "@typescript-eslint/no-shadow": "off",
+        "@typescript-eslint/restrict-template-expressions": "off",
+        "unicorn/no-document-cookie": "off",
+        "@typescript-eslint/no-redeclare": "off",
+        "@typescript-eslint/no-deprecated": "off"
+      }
+    }
+  ];
+}
+var import_eslint_plugin_query, import_eslint_plugin_react, import_eslint_plugin_react_hooks, import_eslint_plugin_react_refresh, import_eslint_plugin_react_you_might_not_need_an_effect, import_local_pkg2, nextJsPackages, vitePackages;
+var init_react = __esm({
+  "src/eslint/configs/react.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_eslint_plugin_query = __toESM(require("@tanstack/eslint-plugin-query"), 1);
+    import_eslint_plugin_react = __toESM(require("eslint-plugin-react"), 1);
+    import_eslint_plugin_react_hooks = __toESM(require("eslint-plugin-react-hooks"), 1);
+    import_eslint_plugin_react_refresh = __toESM(require("eslint-plugin-react-refresh"), 1);
+    import_eslint_plugin_react_you_might_not_need_an_effect = __toESM(require("eslint-plugin-react-you-might-not-need-an-effect"), 1);
+    import_local_pkg2 = require("local-pkg");
+    nextJsPackages = ["next"];
+    vitePackages = ["vite"];
+  }
+});
+
+// src/eslint/presets/react.ts
+var react_exports = {};
+__export(react_exports, {
+  reactPreset: () => reactPreset
+});
+var reactPreset;
+var init_react2 = __esm({
+  "src/eslint/presets/react.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_a11y();
+    init_imports();
+    init_react();
+    init_typescript_strict();
+    init_unicorn();
+    reactPreset = async () => [
+      ...a11y(),
+      ...unicorn(),
+      ...typescriptStrict(),
+      ...imports({ forbidDefaultExport: true }),
+      ...await react()
+    ];
+  }
+});
+
+// src/eslint/presets/node.ts
+var node_exports = {};
+__export(node_exports, {
+  nodePreset: () => nodePreset
+});
+var nodePreset;
+var init_node2 = __esm({
+  "src/eslint/presets/node.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_imports();
+    init_node();
+    init_typescript_strict();
+    init_unicorn();
+    nodePreset = () => [
+      ...node(),
+      ...unicorn(),
+      ...typescriptStrict(),
+      ...imports({ forbidDefaultExport: true })
+    ];
+  }
+});
+
+// src/eslint/index.ts
+var eslint_exports = {};
+__export(eslint_exports, {
+  solvro: () => solvro
+});
+module.exports = __toCommonJS(eslint_exports);
+init_cjs_shims();
+var import_find_up_simple = require("find-up-simple");
+var import_local_pkg3 = require("local-pkg");
+var import_node_path = __toESM(require("path"), 1);
+var import_typescript_eslint4 = __toESM(require("typescript-eslint"), 1);
+
+// src/eslint/presets/base.ts
+init_cjs_shims();
+var import_eslint_config_flat_gitignore = __toESM(require("eslint-config-flat-gitignore"), 1);
+
+// src/eslint/configs/comments.ts
+init_cjs_shims();
+init_plugins();
+function comments() {
+  return [
+    {
+      name: "solvro/eslint-comments/rules",
+      plugins: {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        "eslint-comments": import_eslint_plugin_eslint_comments.default
+      },
+      rules: {
+        "eslint-comments/no-aggregating-enable": "error",
+        "eslint-comments/no-duplicate-disable": "error",
+        "eslint-comments/no-unlimited-disable": "error",
+        "eslint-comments/no-unused-enable": "error"
+      }
+    }
+  ];
+}
+
+// src/eslint/configs/disables.ts
+init_cjs_shims();
+var import_typescript_eslint = __toESM(require("typescript-eslint"), 1);
+
+// src/eslint/globs.ts
+init_cjs_shims();
+var GLOB_SRC_EXT = "?([cm])[jt]s?(x)";
+var GLOB_SRC = "**/*.?([cm])[jt]s?(x)";
+var GLOB_JS = "**/*.?([cm])js";
+var GLOB_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/bun.lockb",
+  "**/build",
+  "**/output",
+  "**/coverage",
+  "**/temp",
+  "**/.temp",
+  "**/tmp",
+  "**/.tmp",
+  "**/.history",
+  "**/.vitepress/cache",
+  "**/.nuxt",
+  "**/.next",
+  "**/.svelte-kit",
+  "**/.vercel",
+  "**/.changeset",
+  "**/.idea",
+  "**/.cache",
+  "**/.output",
+  "**/.vite-inspect",
+  "**/.yarn",
+  "**/vite.config.*.timestamp-*",
+  "**/CHANGELOG*.md",
+  "**/*.min.*",
+  "**/LICENSE*",
+  "**/__snapshots__",
+  "**/auto-import?(s).d.ts",
+  "**/components.d.ts"
+];
+
+// src/eslint/configs/disables.ts
+function disables() {
+  return [
+    {
+      files: [`**/scripts/${GLOB_SRC}`],
+      name: "solvro/disables/scripts",
+      rules: {
+        "antfu/no-top-level-await": "off",
+        "no-console": "off",
+        "@typescript-eslint/explicit-function-return-type": "off"
+      }
+    },
+    {
+      rules: {
+        "prettier/prettier": "off"
+      }
+    },
+    {
+      files: [`**/cli/${GLOB_SRC}`, `**/cli.${GLOB_SRC_EXT}`],
+      name: "solvro/disables/cli",
+      rules: {
+        "antfu/no-top-level-await": "off",
+        "no-console": "off"
+      }
+    },
+    {
+      files: ["**/bin/**/*", `**/bin.${GLOB_SRC_EXT}`],
+      name: "solvro/disables/bin",
+      rules: {
+        "antfu/no-import-dist": "off",
+        "antfu/no-import-node-modules-by-path": "off"
+      }
+    },
+    {
+      files: ["**/*.d.?([cm])ts"],
+      name: "solvro/disables/dts",
+      rules: {
+        "eslint-comments/no-unlimited-disable": "off",
+        "import-x/no-duplicates": "off",
+        "no-restricted-syntax": "off",
+        "unused-imports/no-unused-vars": "off"
+      }
+    },
+    {
+      files: ["**/*.js", "**/*.cjs"],
+      name: "solvro/disables/cjs",
+      rules: {
+        "@typescript-eslint/no-require-imports": "off"
+      }
+    },
+    {
+      files: [`**/*.config.${GLOB_SRC_EXT}`, `**/*.config.*.${GLOB_SRC_EXT}`],
+      name: "solvro/disables/config-files",
+      rules: {
+        "antfu/no-top-level-await": "off",
+        "no-console": "off",
+        "@typescript-eslint/explicit-function-return-type": "off"
+      }
+    },
+    {
+      files: [GLOB_JS],
+      extends: [import_typescript_eslint.default.configs.disableTypeChecked]
+    }
+  ];
+}
+
+// src/eslint/configs/formatters.ts
+init_cjs_shims();
+var import_eslint_config_prettier = __toESM(require("eslint-config-prettier"), 1);
+function formatters() {
+  return [
+    {
+      name: "solvro/prettier",
+      rules: {
+        ...import_eslint_config_prettier.default.rules,
+        curly: "error"
+      }
+    }
+  ];
+}
+
+// src/eslint/configs/ignores.ts
+init_cjs_shims();
+function ignores() {
+  return [
+    {
+      ignores: [...GLOB_EXCLUDE],
+      name: "solvro/ignores"
+    }
+  ];
+}
+
+// src/eslint/configs/javascript.ts
+init_cjs_shims();
+var import_js = __toESM(require("@eslint/js"), 1);
+var import_globals = __toESM(require("globals"), 1);
+init_plugins();
+function javascript() {
+  return [
+    {
+      languageOptions: {
+        ecmaVersion: 2022,
+        globals: {
+          ...import_globals.default.browser,
+          ...import_globals.default.es2021,
+          ...import_globals.default.node,
+          document: "readonly",
+          navigator: "readonly",
+          window: "readonly"
+        },
+        parserOptions: {
+          ecmaFeatures: {
+            jsx: true
+          },
+          ecmaVersion: 2022,
+          sourceType: "module"
+        },
+        sourceType: "module"
+      },
+      linterOptions: {
+        reportUnusedDisableDirectives: true
+      },
+      name: "solvro/javascript/setup"
+    },
+    {
+      name: "solvro/javascript/rules",
+      plugins: {
+        antfu: import_eslint_plugin_antfu.default,
+        "unused-imports": import_eslint_plugin_unused_imports.default
+      },
+      rules: {
+        ...import_js.default.configs.recommended.rules,
+        "accessor-pairs": [
+          "error",
+          { enforceForClassMembers: true, setWithoutGet: true }
+        ],
+        curly: "error",
+        "array-callback-return": "error",
+        "block-scoped-var": "error",
+        "constructor-super": "error",
+        "default-case-last": "error",
+        "dot-notation": ["error", { allowKeywords: true }],
+        eqeqeq: ["error", "smart"],
+        "new-cap": [
+          "error",
+          { capIsNew: false, newIsCap: true, properties: true }
+        ],
+        "no-alert": "error",
+        "no-array-constructor": "error",
+        "no-async-promise-executor": "error",
+        "no-caller": "error",
+        "no-case-declarations": "error",
+        "no-class-assign": "error",
+        "no-compare-neg-zero": "error",
+        "no-cond-assign": ["error", "always"],
+        "no-console": ["error", { allow: ["warn", "error"] }],
+        "no-const-assign": "error",
+        "no-control-regex": "error",
+        "no-debugger": "error",
+        "no-delete-var": "error",
+        "no-dupe-args": "error",
+        "no-dupe-class-members": "error",
+        "no-dupe-keys": "error",
+        "no-duplicate-case": "error",
+        "no-empty": ["error", { allowEmptyCatch: true }],
+        "no-empty-character-class": "error",
+        "no-empty-pattern": "error",
+        "no-eval": "error",
+        "no-ex-assign": "error",
+        "no-extend-native": "error",
+        "no-extra-bind": "error",
+        "no-extra-boolean-cast": "error",
+        "no-fallthrough": "error",
+        "no-func-assign": "error",
+        "no-global-assign": "error",
+        "no-implied-eval": "error",
+        "no-implicit-coercion": "error",
+        "no-import-assign": "error",
+        "no-invalid-regexp": "error",
+        "no-irregular-whitespace": "error",
+        "no-iterator": "error",
+        "no-labels": ["error", { allowLoop: false, allowSwitch: false }],
+        "no-lone-blocks": "error",
+        "no-loss-of-precision": "error",
+        "no-misleading-character-class": "error",
+        "no-multi-str": "error",
+        "no-new": "error",
+        "no-new-func": "error",
+        "no-new-native-nonconstructor": "error",
+        "no-new-wrappers": "error",
+        "no-obj-calls": "error",
+        "no-octal": "error",
+        "no-octal-escape": "error",
+        "no-proto": "error",
+        "no-prototype-builtins": "error",
+        "no-redeclare": ["error", { builtinGlobals: false }],
+        "no-regex-spaces": "error",
+        "no-restricted-globals": [
+          "error",
+          { message: "Use `globalThis` instead.", name: "global" },
+          { message: "Use `globalThis` instead.", name: "self" }
+        ],
+        "no-restricted-properties": [
+          "error",
+          {
+            message: "Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.",
+            property: "__proto__"
+          },
+          {
+            message: "Use `Object.defineProperty` instead.",
+            property: "__defineGetter__"
+          },
+          {
+            message: "Use `Object.defineProperty` instead.",
+            property: "__defineSetter__"
+          },
+          {
+            message: "Use `Object.getOwnPropertyDescriptor` instead.",
+            property: "__lookupGetter__"
+          },
+          {
+            message: "Use `Object.getOwnPropertyDescriptor` instead.",
+            property: "__lookupSetter__"
+          }
+        ],
+        "no-restricted-syntax": [
+          "error",
+          "TSEnumDeclaration[const=true]",
+          "TSExportAssignment"
+        ],
+        "no-self-assign": ["error", { props: true }],
+        "no-self-compare": "error",
+        "no-sequences": "error",
+        "no-shadow-restricted-names": "error",
+        "no-sparse-arrays": "error",
+        "no-template-curly-in-string": "error",
+        "no-this-before-super": "error",
+        "no-throw-literal": "error",
+        "no-undef-init": "error",
+        "no-unexpected-multiline": "error",
+        "no-unmodified-loop-condition": "error",
+        "no-unneeded-ternary": ["error", { defaultAssignment: false }],
+        "no-unreachable": "error",
+        "no-unreachable-loop": "error",
+        "no-unsafe-finally": "error",
+        "no-unsafe-negation": "error",
+        "no-unused-expressions": [
+          "error",
+          {
+            allowShortCircuit: true,
+            allowTaggedTemplates: true,
+            allowTernary: true
+          }
+        ],
+        "no-useless-backreference": "error",
+        "no-useless-call": "error",
+        "no-useless-catch": "error",
+        "no-useless-computed-key": "error",
+        "no-useless-constructor": "error",
+        "no-useless-rename": "error",
+        "no-useless-return": "error",
+        "no-var": "error",
+        "no-with": "error",
+        "object-shorthand": [
+          "error",
+          "always",
+          {
+            avoidQuotes: true,
+            ignoreConstructors: false
+          }
+        ],
+        "one-var": ["error", { initialized: "never" }],
+        "prefer-arrow-callback": [
+          "error",
+          {
+            allowNamedFunctions: false,
+            allowUnboundThis: true
+          }
+        ],
+        "prefer-const": [
+          "error",
+          {
+            destructuring: "all",
+            ignoreReadBeforeAssign: true
+          }
+        ],
+        "prefer-exponentiation-operator": "error",
+        "prefer-promise-reject-errors": "error",
+        "prefer-regex-literals": ["error", { disallowRedundantWrapping: true }],
+        "prefer-rest-params": "error",
+        "prefer-spread": "error",
+        "prefer-template": "error",
+        "symbol-description": "error",
+        "unicode-bom": ["error", "never"],
+        "unused-imports/no-unused-imports": "error",
+        "unused-imports/no-unused-vars": [
+          "error",
+          {
+            args: "after-used",
+            argsIgnorePattern: "^_",
+            ignoreRestSiblings: true,
+            vars: "all",
+            varsIgnorePattern: "^_"
+          }
+        ],
+        "use-isnan": [
+          "error",
+          { enforceForIndexOf: true, enforceForSwitchCase: true }
+        ],
+        "valid-typeof": ["error", { requireStringLiterals: true }],
+        "vars-on-top": "error",
+        yoda: ["error", "never"]
+      }
+    }
+  ];
+}
+
+// src/eslint/configs/jsdoc.ts
+init_cjs_shims();
+var import_eslint_plugin_jsdoc = __toESM(require("eslint-plugin-jsdoc"), 1);
+function jsdoc() {
+  return [
+    {
+      name: "solvro/jsdoc/rules",
+      plugins: {
+        jsdoc: import_eslint_plugin_jsdoc.default
+      },
+      rules: {
+        "jsdoc/check-access": "warn",
+        "jsdoc/check-param-names": "warn",
+        "jsdoc/check-property-names": "warn",
+        "jsdoc/check-types": "warn",
+        "jsdoc/empty-tags": "warn",
+        "jsdoc/implements-on-classes": "warn",
+        "jsdoc/no-defaults": "warn",
+        "jsdoc/no-multi-asterisks": "warn",
+        "jsdoc/require-param-name": "warn",
+        "jsdoc/require-property": "warn",
+        "jsdoc/require-property-description": "warn",
+        "jsdoc/require-property-name": "warn",
+        "jsdoc/require-returns-check": "warn",
+        "jsdoc/require-returns-description": "warn",
+        "jsdoc/require-yields-check": "warn"
+      }
+    }
+  ];
+}
+
+// src/eslint/configs/typescript-relaxed.ts
+init_cjs_shims();
+var import_typescript_eslint2 = __toESM(require("typescript-eslint"), 1);
+function typescriptRelaxed() {
+  return [
+    ...import_typescript_eslint2.default.configs.recommendedTypeChecked,
+    ...import_typescript_eslint2.default.configs.stylisticTypeChecked,
+    {
+      name: "solvro/typescript-relaxed/rules",
+      rules: {
+        "@typescript-eslint/no-unsafe-return": "off",
+        "@typescript-eslint/require-await": "off",
+        "@typescript-eslint/no-misused-promises": [
+          "error",
+          {
+            checksVoidReturn: false
+          }
+        ],
+        "no-useless-constructor": "off",
+        "@typescript-eslint/no-useless-constructor": "error",
+        "unused-imports/no-unused-vars": "off",
+        "@typescript-eslint/no-unused-vars": [
+          "error",
+          {
+            args: "all",
+            argsIgnorePattern: "^_",
+            destructuredArrayIgnorePattern: "^_",
+            varsIgnorePattern: "^_",
+            ignoreRestSiblings: true
+          }
+        ],
+        "@typescript-eslint/no-empty-object-type": "off",
+        "@typescript-eslint/no-unnecessary-condition": "warn",
+        "@typescript-eslint/no-non-null-assertion": "error",
+        "@typescript-eslint/no-unnecessary-template-expression": "error",
+        "@typescript-eslint/strict-boolean-expressions": [
+          "error",
+          {
+            allowNullableObject: false
+          }
+        ]
+      }
+    }
+  ];
+}
+
+// src/eslint/presets/base.ts
+var basePreset = () => [
+  (0, import_eslint_config_flat_gitignore.default)(),
+  ...javascript(),
+  ...jsdoc(),
+  ...comments(),
+  ...typescriptRelaxed()
+];
+var defaultOverridesPreset = () => [
+  ...ignores(),
+  ...formatters(),
+  ...disables()
+];
+
+// src/eslint/index.ts
+var solvro = async (...overrides) => {
+  const isAdonis = await (0, import_local_pkg3.isPackageListed)("@adonisjs/core");
+  const isReact = await (0, import_local_pkg3.isPackageListed)("react");
+  const isNestJs = await (0, import_local_pkg3.isPackageListed)("@nestjs/core");
+  if (isReact && isAdonis) {
+    throw new Error("You can't use both Adonis and React in the same project");
+  }
+  const configs = basePreset();
+  const projectConfigs = [];
+  if (isAdonis) {
+    const { adonisPreset: adonisPreset2 } = await Promise.resolve().then(() => (init_adonis(), adonis_exports));
+    projectConfigs.push(...adonisPreset2());
+  } else if (isNestJs) {
+    const { nestjsPreset: nestjsPreset2 } = await Promise.resolve().then(() => (init_nestjs(), nestjs_exports));
+    projectConfigs.push(...await nestjsPreset2());
+  } else if (isReact) {
+    const { reactPreset: reactPreset2 } = await Promise.resolve().then(() => (init_react2(), react_exports));
+    projectConfigs.push(...await reactPreset2());
+  } else {
+    const { nodePreset: nodePreset2 } = await Promise.resolve().then(() => (init_node2(), node_exports));
+    projectConfigs.push(...nodePreset2());
+  }
+  const tsConfigPath = (0, import_find_up_simple.findUpSync)("tsconfig.json", {
+    cwd: process.cwd()
+  });
+  if (tsConfigPath == null) {
+    throw new Error("No tsconfig.json found");
+  }
+  const rootDirectory = import_node_path.default.dirname(tsConfigPath);
+  const tsConfig = {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: rootDirectory
+      }
+    }
+  };
+  const defaultOverrides = defaultOverridesPreset();
+  return import_typescript_eslint4.default.config(
+    ...configs,
+    tsConfig,
+    ...projectConfigs,
+    ...defaultOverrides,
+    ...overrides
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  solvro
+});
+//# sourceMappingURL=index.cjs.map