@solvro/config 1.1.0 → 1.2.0

package/dist/eslint-config/index.cjs

@@ -34,12 +34,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl, importMetaUrl;
 var init_cjs_shims = __esm({
   "node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
-    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
-    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
   }
 });
 
@@ -259,76 +256,11 @@ var require_eslint_config_prettier = __commonJS({
 // eslint-config/index.ts
 var eslint_config_exports = {};
 __export(eslint_config_exports, {
-  GLOB_ALL_SRC: () => GLOB_ALL_SRC,
-  GLOB_EXCLUDE: () => GLOB_EXCLUDE,
-  GLOB_HTML: () => GLOB_HTML,
-  GLOB_JS: () => GLOB_JS,
-  GLOB_JSON: () => GLOB_JSON,
-  GLOB_JSON5: () => GLOB_JSON5,
-  GLOB_JSX: () => GLOB_JSX,
-  GLOB_MARKDOWN: () => GLOB_MARKDOWN,
-  GLOB_MARKDOWN_CODE: () => GLOB_MARKDOWN_CODE,
-  GLOB_MARKDOWN_IN_MARKDOWN: () => GLOB_MARKDOWN_IN_MARKDOWN,
-  GLOB_SRC: () => GLOB_SRC,
-  GLOB_SRC_EXT: () => GLOB_SRC_EXT,
-  GLOB_STYLE: () => GLOB_STYLE,
-  GLOB_SVG: () => GLOB_SVG,
-  GLOB_TESTS: () => GLOB_TESTS,
-  GLOB_TOML: () => GLOB_TOML,
-  GLOB_TS: () => GLOB_TS,
-  GLOB_TSX: () => GLOB_TSX,
-  GLOB_XML: () => GLOB_XML,
-  combine: () => combine,
-  command: () => command,
-  comments: () => comments,
-  default: () => eslint_config_default,
-  disables: () => disables,
-  ensurePackages: () => ensurePackages,
-  formatters: () => formatters,
-  getOverrides: () => getOverrides,
-  ignores: () => ignores,
-  imports: () => imports,
-  interopDefault: () => interopDefault,
-  isInEditorEnv: () => isInEditorEnv,
-  isInGitHooksOrLintStaged: () => isInGitHooksOrLintStaged,
-  isPackageInScope: () => isPackageInScope,
-  javascript: () => javascript,
-  jsdoc: () => jsdoc,
-  jsx: () => jsx,
-  markdown: () => markdown,
-  node: () => node,
-  parserPlain: () => parserPlain,
-  react: () => react,
-  regexp: () => regexp,
-  resolveSubOptions: () => resolveSubOptions,
-  solvro: () => solvro,
-  test: () => test,
-  toArray: () => toArray,
-  typescript: () => typescript,
-  unicorn: () => unicorn
+  solvro: () => solvro
 });
 module.exports = __toCommonJS(eslint_config_exports);
 init_cjs_shims();
-
-// eslint-config/factory.ts
-init_cjs_shims();
-var import_eslint_flat_config_utils = require("eslint-flat-config-utils");
-var import_local_pkg3 = require("local-pkg");
-
-// eslint-config/configs/index.ts
-init_cjs_shims();
-
-// eslint-config/configs/command.ts
-init_cjs_shims();
-var import_config = __toESM(require("eslint-plugin-command/config"), 1);
-async function command() {
-  return [
-    {
-      ...(0, import_config.default)(),
-      name: "solvro/command/rules"
-    }
-  ];
-}
+var import_typescript_eslint2 = __toESM(require("typescript-eslint"), 1);
 
 // eslint-config/configs/comments.ts
 init_cjs_shims();
@@ -344,11 +276,12 @@ var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
 var import_eslint_plugin_unused_imports = __toESM(require("eslint-plugin-unused-imports"), 1);
 
 // eslint-config/configs/comments.ts
-async function comments() {
+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: {
@@ -368,19 +301,7 @@ init_cjs_shims();
 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_JSX = "**/*.?([cm])jsx";
-var GLOB_TS = "**/*.?([cm])ts";
-var GLOB_TSX = "**/*.?([cm])tsx";
-var GLOB_STYLE = "**/*.{c,le,sc}ss";
-var GLOB_JSON = "**/*.json";
-var GLOB_JSON5 = "**/*.json5";
 var GLOB_MARKDOWN = "**/*.md";
-var GLOB_MARKDOWN_IN_MARKDOWN = "**/*.md/*.md";
-var GLOB_TOML = "**/*.toml";
-var GLOB_XML = "**/*.xml";
-var GLOB_SVG = "**/*.svg";
-var GLOB_HTML = "**/*.htm?(l)";
 var GLOB_MARKDOWN_CODE = `${GLOB_MARKDOWN}/${GLOB_SRC}`;
 var GLOB_TESTS = [
   `**/__tests__/**/*.${GLOB_SRC_EXT}`,
@@ -389,15 +310,6 @@ var GLOB_TESTS = [
   `**/*.bench.${GLOB_SRC_EXT}`,
   `**/*.benchmark.${GLOB_SRC_EXT}`
 ];
-var GLOB_ALL_SRC = [
-  GLOB_SRC,
-  GLOB_STYLE,
-  GLOB_JSON,
-  GLOB_JSON5,
-  GLOB_MARKDOWN,
-  GLOB_XML,
-  GLOB_HTML
-];
 var GLOB_EXCLUDE = [
   "**/node_modules",
   "**/dist",
@@ -433,7 +345,7 @@ var GLOB_EXCLUDE = [
 ];
 
 // eslint-config/configs/disables.ts
-async function disables() {
+function disables() {
   return [
     {
       files: [`**/scripts/${GLOB_SRC}`],
@@ -491,86 +403,22 @@ async function disables() {
 
 // eslint-config/configs/formatters.ts
 init_cjs_shims();
-
-// eslint-config/utils.ts
-init_cjs_shims();
-var import_local_pkg = require("local-pkg");
-var import_node_process = __toESM(require("process"), 1);
-var import_node_url = require("url");
-var scopeUrl = (0, import_node_url.fileURLToPath)(new URL(".", importMetaUrl));
-var isCwdInScope = (0, import_local_pkg.isPackageExists)("@solvro/config");
-var parserPlain = {
-  meta: {
-    name: "parser-plain"
-  },
-  parseForESLint: (code) => ({
-    ast: {
-      body: [],
-      comments: [],
-      loc: { end: code.length, start: 0 },
-      range: [0, code.length],
-      tokens: [],
-      type: "Program"
-    },
-    scopeManager: null,
-    services: { isPlain: true },
-    visitorKeys: {
-      Program: []
+var import_eslint_config_prettier = __toESM(require_eslint_config_prettier(), 1);
+function formatters() {
+  return [
+    {
+      name: "solvro/prettier",
+      ...import_eslint_config_prettier.default
     }
-  })
-};
-async function combine(...configs2) {
-  const resolved = await Promise.all(configs2);
-  return resolved.flat();
-}
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-async function interopDefault(m) {
-  const resolved = await m;
-  return resolved.default || resolved;
-}
-function isPackageInScope(name) {
-  return (0, import_local_pkg.isPackageExists)(name, { paths: [scopeUrl] });
-}
-async function ensurePackages(packages) {
-  if (import_node_process.default.env.CI || import_node_process.default.stdout.isTTY === false || isCwdInScope === false)
-    return;
-  const nonExistingPackages = packages.filter(
-    (i) => i && !isPackageInScope(i)
-  );
-  if (nonExistingPackages.length === 0) return;
-  const p = await import("@clack/prompts");
-  const result = await p.confirm({
-    message: `${nonExistingPackages.length === 1 ? "Package is" : "Packages are"} required for this config: ${nonExistingPackages.join(", ")}. Do you want to install them?`
-  });
-  if (result)
-    await import("@antfu/install-pkg").then(
-      (i) => i.installPackage(nonExistingPackages, { dev: true })
-    );
-}
-function isInEditorEnv() {
-  if (import_node_process.default.env.CI) return false;
-  if (isInGitHooksOrLintStaged()) return false;
-  return !!(import_node_process.default.env.VSCODE_PID || import_node_process.default.env.VSCODE_CWD || import_node_process.default.env.JETBRAINS_IDE || import_node_process.default.env.VIM || import_node_process.default.env.NVIM);
-}
-function isInGitHooksOrLintStaged() {
-  return !!(import_node_process.default.env.GIT_PARAMS || import_node_process.default.env.VSCODE_GIT_COMMAND || import_node_process.default.env.npm_lifecycle_script?.startsWith("lint-staged"));
-}
-
-// eslint-config/configs/formatters.ts
-async function formatters() {
-  await ensurePackages(["eslint-plugin-prettier"]);
-  const prettierConfig = await interopDefault(Promise.resolve().then(() => __toESM(require_eslint_config_prettier(), 1)));
-  return [prettierConfig];
+  ];
 }
 
 // eslint-config/configs/ignores.ts
 init_cjs_shims();
-async function ignores(userIgnores = []) {
+function ignores() {
   return [
     {
-      ignores: [...GLOB_EXCLUDE, ...userIgnores],
+      ignores: [...GLOB_EXCLUDE],
       name: "solvro/ignores"
     }
   ];
@@ -578,12 +426,13 @@ async function ignores(userIgnores = []) {
 
 // eslint-config/configs/imports.ts
 init_cjs_shims();
-async function imports() {
+function imports() {
   return [
     {
       name: "solvro/imports/rules",
       plugins: {
         antfu: import_eslint_plugin_antfu.default,
+        // @ts-expect-error ???
         "import-x": pluginImport
       },
       rules: {
@@ -603,9 +452,9 @@ async function imports() {
 
 // eslint-config/configs/javascript.ts
 init_cjs_shims();
+var import_js = __toESM(require("@eslint/js"), 1);
 var import_globals = __toESM(require("globals"), 1);
-async function javascript(options = {}) {
-  const { isInEditor = false, overrides = {} } = options;
+function javascript() {
   return [
     {
       languageOptions: {
@@ -639,6 +488,7 @@ async function javascript(options = {}) {
         "unused-imports": import_eslint_plugin_unused_imports.default
       },
       rules: {
+        ...import_js.default.configs.recommended.rules,
         "accessor-pairs": [
           "error",
           { enforceForClassMembers: true, setWithoutGet: true }
@@ -814,7 +664,7 @@ async function javascript(options = {}) {
         "prefer-template": "error",
         "symbol-description": "error",
         "unicode-bom": ["error", "never"],
-        "unused-imports/no-unused-imports": isInEditor ? "off" : "error",
+        "unused-imports/no-unused-imports": "error",
         "unused-imports/no-unused-vars": [
           "error",
           {
@@ -831,8 +681,7 @@ async function javascript(options = {}) {
         ],
         "valid-typeof": ["error", { requireStringLiterals: true }],
         "vars-on-top": "error",
-        yoda: ["error", "never"],
-        ...overrides
+        yoda: ["error", "never"]
       }
     }
   ];
@@ -840,12 +689,13 @@ async function javascript(options = {}) {
 
 // eslint-config/configs/jsdoc.ts
 init_cjs_shims();
-async function jsdoc() {
+var import_eslint_plugin_jsdoc = __toESM(require("eslint-plugin-jsdoc"), 1);
+function jsdoc() {
   return [
     {
       name: "solvro/jsdoc/rules",
       plugins: {
-        jsdoc: await interopDefault(import("eslint-plugin-jsdoc"))
+        jsdoc: import_eslint_plugin_jsdoc.default
       },
       rules: {
         "jsdoc/check-access": "warn",
@@ -868,105 +718,9 @@ async function jsdoc() {
   ];
 }
 
-// eslint-config/configs/jsx.ts
-init_cjs_shims();
-async function jsx() {
-  return [
-    {
-      files: [GLOB_JSX, GLOB_TSX],
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            jsx: true
-          }
-        }
-      },
-      name: "solvro/jsx/setup"
-    }
-  ];
-}
-
-// eslint-config/configs/markdown.ts
-init_cjs_shims();
-var import_eslint_merge_processors = require("eslint-merge-processors");
-async function markdown(options = {}) {
-  const {
-    componentExts = [],
-    files = [GLOB_MARKDOWN],
-    overrides = {}
-  } = options;
-  const markdown2 = await interopDefault(import("@eslint/markdown"));
-  return [
-    {
-      name: "solvro/markdown/setup",
-      plugins: {
-        markdown: markdown2
-      }
-    },
-    {
-      files,
-      ignores: [GLOB_MARKDOWN_IN_MARKDOWN],
-      name: "solvro/markdown/processor",
-      // `eslint-plugin-markdown` only creates virtual files for code blocks,
-      // but not the markdown file itself. We use `eslint-merge-processors` to
-      // add a pass-through processor for the markdown file itself.
-      processor: (0, import_eslint_merge_processors.mergeProcessors)([
-        markdown2.processors.markdown,
-        import_eslint_merge_processors.processorPassThrough
-      ])
-    },
-    {
-      files,
-      languageOptions: {
-        parser: parserPlain
-      },
-      name: "solvro/markdown/parser"
-    },
-    {
-      files: [
-        GLOB_MARKDOWN_CODE,
-        ...componentExts.map((ext) => `${GLOB_MARKDOWN}/**/*.${ext}`)
-      ],
-      languageOptions: {
-        parserOptions: {
-          ecmaFeatures: {
-            impliedStrict: true
-          }
-        }
-      },
-      name: "solvro/markdown/disables",
-      rules: {
-        "antfu/no-top-level-await": "off",
-        "no-alert": "off",
-        "no-console": "off",
-        "no-labels": "off",
-        "no-lone-blocks": "off",
-        "no-restricted-syntax": "off",
-        "no-undef": "off",
-        "no-unused-expressions": "off",
-        "no-unused-labels": "off",
-        "no-unused-vars": "off",
-        "node/prefer-global/process": "off",
-        "@typescript-eslint/consistent-type-imports": "off",
-        "@typescript-eslint/explicit-function-return-type": "off",
-        "@typescript-eslint/no-namespace": "off",
-        "@typescript-eslint/no-redeclare": "off",
-        "@typescript-eslint/no-require-imports": "off",
-        "@typescript-eslint/no-unused-expressions": "off",
-        "@typescript-eslint/no-unused-vars": "off",
-        "@typescript-eslint/no-use-before-define": "off",
-        "unicode-bom": "off",
-        "unused-imports/no-unused-imports": "off",
-        "unused-imports/no-unused-vars": "off",
-        ...overrides
-      }
-    }
-  ];
-}
-
 // eslint-config/configs/node.ts
 init_cjs_shims();
-async function node() {
+function node() {
   return [
     {
       name: "solvro/node/rules",
@@ -989,61 +743,41 @@ async function node() {
 
 // eslint-config/configs/react.ts
 init_cjs_shims();
-var import_local_pkg2 = require("local-pkg");
-var ReactRefreshAllowConstantExportPackages = ["vite"];
+var import_eslint_plugin_next = __toESM(require("@next/eslint-plugin-next"), 1);
+var import_eslint_plugin_react = __toESM(require("eslint-plugin-react"), 1);
+var import_eslint_plugin_react_hooks = __toESM(require("eslint-plugin-react-hooks"), 1);
+var import_eslint_plugin_react_refresh = __toESM(require("eslint-plugin-react-refresh"), 1);
+var import_local_pkg = require("local-pkg");
 var NextJsPackages = ["next"];
-async function react(options = {}) {
-  const {
-    files = [GLOB_SRC],
-    filesTypeAware = [GLOB_TS, GLOB_TSX],
-    ignoresTypeAware = [`${GLOB_MARKDOWN}/**`],
-    overrides = {},
-    tsconfigPath
-  } = options;
-  await ensurePackages([
-    "eslint-plugin-react",
-    "eslint-plugin-react-hooks",
-    "eslint-plugin-react-refresh"
-  ]);
-  const isTypeAware = !!tsconfigPath;
-  const typeAwareRules = {
-    "react/jsx-no-leaked-render": "warn"
-  };
-  const [pluginReact, pluginReactHooks, pluginReactRefresh] = await Promise.all(
-    [
-      interopDefault(import("eslint-plugin-react")),
-      interopDefault(import("eslint-plugin-react-hooks")),
-      interopDefault(import("eslint-plugin-react-refresh"))
-    ]
-  );
-  const isAllowConstantExport = ReactRefreshAllowConstantExportPackages.some(
-    (i) => (0, import_local_pkg2.isPackageExists)(i)
-  );
-  const isUsingNext = NextJsPackages.some((i) => (0, import_local_pkg2.isPackageExists)(i));
+function react() {
+  const isUsingNext = NextJsPackages.some((index) => (0, import_local_pkg.isPackageExists)(index));
   const nextjsConfig = [];
   if (isUsingNext) {
-    await ensurePackages(["@next/eslint-plugin-next"]);
-    const nextPlugin = await interopDefault(import("@next/eslint-plugin-next"));
     nextjsConfig.push({
       name: "solvro/next/setup",
       plugins: {
-        "@next/next": nextPlugin
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        "@next/next": import_eslint_plugin_next.default
       },
-      rules: nextPlugin.configs.recommended.rules
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+      rules: import_eslint_plugin_next.default.configs.recommended.rules
     });
   }
   return [
     {
       name: "solvro/react/setup",
       plugins: {
-        react: pluginReact,
-        "react-hooks": pluginReactHooks,
-        "react-refresh": pluginReactRefresh
+        // @ts-expect-error ???
+        react: import_eslint_plugin_react.default,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        "react-hooks": import_eslint_plugin_react_hooks.default,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        "react-refresh": import_eslint_plugin_react_refresh.default
       }
     },
     ...nextjsConfig,
     {
-      files,
+      files: ["**/*.{js,jsx,mjs,cjs,ts,tsx}"],
       languageOptions: {
         parserOptions: {
           ecmaFeatures: {
@@ -1059,18 +793,18 @@ async function react(options = {}) {
       },
       name: "solvro/react/rules",
       rules: {
-        ...pluginReact.configs.flat?.recommended.rules,
-        ...pluginReact.configs.flat?.["jsx-runtime"].rules,
+        ...import_eslint_plugin_react.default.configs.flat?.recommended.rules,
+        ...import_eslint_plugin_react.default.configs.flat?.["jsx-runtime"].rules,
+        "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/jsx-no-leaked-render": "warn",
         // react refresh
         "react-refresh/only-export-components": [
           "warn",
           {
-            allowConstantExport: isAllowConstantExport,
+            allowConstantExport: false,
             allowExportNames: [
               ...isUsingNext ? [
                 "dynamic",
@@ -1089,95 +823,7 @@ async function react(options = {}) {
               ] : []
             ]
           }
-        ],
-        // overrides
-        ...overrides
-      }
-    },
-    ...isTypeAware ? [
-      {
-        files: filesTypeAware,
-        ignores: ignoresTypeAware,
-        name: "antfu/react/type-aware-rules",
-        rules: {
-          ...typeAwareRules
-        }
-      }
-    ] : []
-  ];
-}
-
-// eslint-config/configs/regexp.ts
-init_cjs_shims();
-var import_eslint_plugin_regexp = require("eslint-plugin-regexp");
-async function regexp(options = {}) {
-  const config = import_eslint_plugin_regexp.configs["flat/recommended"];
-  const rules = {
-    ...config.rules
-  };
-  if (options.level === "warn") {
-    for (const key in rules) {
-      if (rules[key] === "error") rules[key] = "warn";
-    }
-  }
-  return [
-    {
-      ...config,
-      name: "solvro/regexp/rules",
-      rules: {
-        ...rules,
-        ...options.overrides
-      }
-    }
-  ];
-}
-
-// eslint-config/configs/test.ts
-init_cjs_shims();
-var _pluginTest;
-async function test(options = {}) {
-  const { files = GLOB_TESTS, isInEditor = false, overrides = {} } = options;
-  const [pluginVitest, pluginNoOnlyTests] = await Promise.all([
-    interopDefault(import("@vitest/eslint-plugin")),
-    // @ts-expect-error missing types
-    interopDefault(import("eslint-plugin-no-only-tests"))
-  ]);
-  _pluginTest = _pluginTest || {
-    ...pluginVitest,
-    rules: {
-      ...pluginVitest.rules,
-      // extend `test/no-only-tests` rule
-      ...pluginNoOnlyTests.rules
-    }
-  };
-  return [
-    {
-      name: "solvro/test/setup",
-      plugins: {
-        "no-only-tests": _pluginTest
-      }
-    },
-    {
-      files,
-      name: "solvro/test/rules",
-      rules: {
-        "no-only-tests/consistent-test-it": [
-          "error",
-          { fn: "it", withinDescribe: "it" }
-        ],
-        "no-only-tests/no-identical-title": "error",
-        "no-only-tests/no-import-node-test": "error",
-        "no-only-tests/no-only-tests": isInEditor ? "off" : "error",
-        "no-only-tests/prefer-hooks-in-order": "error",
-        "no-only-tests/prefer-lowercase-title": "error",
-        // Disables
-        ...{
-          "antfu/no-top-level-await": "off",
-          "no-unused-expressions": "off",
-          "node/prefer-global/process": "off",
-          "@typescript-eslint/explicit-function-return-type": "off"
-        },
-        ...overrides
+        ]
       }
     }
   ];
@@ -1185,100 +831,22 @@ async function test(options = {}) {
 
 // eslint-config/configs/typescript.ts
 init_cjs_shims();
-var import_node_process2 = __toESM(require("process"), 1);
-async function typescript(options = {}) {
-  const {
-    componentExts = [],
-    overrides = {},
-    overridesTypeAware = {},
-    parserOptions = {},
-    type = "app"
-  } = options;
-  const files = options.files ?? [
-    GLOB_TS,
-    GLOB_TSX,
-    ...componentExts.map((ext) => `**/*.${ext}`)
-  ];
-  const filesTypeAware = options.filesTypeAware ?? [GLOB_TS, GLOB_TSX];
-  const ignoresTypeAware = options.ignoresTypeAware ?? [`${GLOB_MARKDOWN}/**`];
-  const tsconfigPath = options?.tsconfigPath ? options.tsconfigPath : void 0;
-  const isTypeAware = !!tsconfigPath;
-  const typeAwareRules = {
-    "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/no-unnecessary-type-assertion": "error",
-    "@typescript-eslint/no-unsafe-argument": "error",
-    "@typescript-eslint/no-unsafe-assignment": "error",
-    "@typescript-eslint/no-unsafe-call": "error",
-    "@typescript-eslint/no-unsafe-member-access": "error",
-    "@typescript-eslint/no-unsafe-return": "error",
-    "@typescript-eslint/promise-function-async": "error",
-    "@typescript-eslint/restrict-plus-operands": "error",
-    "@typescript-eslint/restrict-template-expressions": "error",
-    "@typescript-eslint/return-await": ["error", "in-try-catch"],
-    "@typescript-eslint/strict-boolean-expressions": [
-      "error",
-      { allowNullableBoolean: true, allowNullableObject: true }
-    ],
-    "@typescript-eslint/switch-exhaustiveness-check": "error",
-    "@typescript-eslint/unbound-method": "error"
-  };
-  const [pluginTs, parserTs] = await Promise.all([
-    interopDefault(import("@typescript-eslint/eslint-plugin")),
-    interopDefault(import("@typescript-eslint/parser"))
-  ]);
-  function makeParser(typeAware, files2, ignores2) {
-    return {
-      files: files2,
-      ...ignores2 ? { ignores: ignores2 } : {},
-      languageOptions: {
-        parser: parserTs,
-        parserOptions: {
-          extraFileExtensions: componentExts.map((ext) => `.${ext}`),
-          sourceType: "module",
-          ...typeAware ? {
-            projectService: {
-              allowDefaultProject: ["./*.js"],
-              defaultProject: tsconfigPath
-            },
-            tsconfigRootDir: import_node_process2.default.cwd()
-          } : {},
-          ...parserOptions
-        }
-      },
-      name: `solvro/typescript/${typeAware ? "type-aware-parser" : "parser"}`
-    };
-  }
+var import_typescript_eslint = __toESM(require("typescript-eslint"), 1);
+function typescript() {
   return [
+    // @ts-expect-error ???
+    import_typescript_eslint.default.configs.strictTypeChecked,
+    // @ts-expect-error ???
+    import_typescript_eslint.default.configs.stylisticTypeChecked,
     {
-      // Install the plugins without globs, so they can be configured separately.
       name: "solvro/typescript/setup",
       plugins: {
-        antfu: import_eslint_plugin_antfu.default,
-        "@typescript-eslint": pluginTs
+        antfu: import_eslint_plugin_antfu.default
       }
     },
-    // assign type-aware parser for type-aware files and type-unaware parser for the rest
-    ...isTypeAware ? [
-      makeParser(false, files),
-      makeParser(true, filesTypeAware, ignoresTypeAware)
-    ] : [makeParser(false, files)],
     {
-      files,
       name: "solvro/typescript/rules",
       rules: {
-        ...pluginTs.configs["eslint-recommended"].overrides[0].rules,
-        ...pluginTs.configs.strict.rules,
-        "no-dupe-class-members": "off",
-        "no-redeclare": "off",
-        "no-use-before-define": "off",
-        "no-useless-constructor": "off",
         "@typescript-eslint/ban-ts-comment": [
           "error",
           { "ts-expect-error": "allow-with-description" }
@@ -1326,253 +894,121 @@ async function typescript(options = {}) {
         "@typescript-eslint/no-wrapper-object-types": "error",
         "@typescript-eslint/triple-slash-reference": "off",
         "@typescript-eslint/unified-signatures": "off",
-        ...type === "lib" ? {
-          "@typescript-eslint/explicit-function-return-type": [
-            "error",
-            {
-              allowExpressions: true,
-              allowHigherOrderFunctions: true,
-              allowIIFEs: true
-            }
-          ]
-        } : {},
-        ...overrides
-      }
-    },
-    ...isTypeAware ? [
-      {
-        files: filesTypeAware,
-        ignores: ignoresTypeAware,
-        name: "solvro/typescript/rules-type-aware",
-        rules: {
-          ...typeAwareRules,
-          ...overridesTypeAware
-        }
+        // 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"
       }
-    ] : []
+    }
   ];
 }
 
 // eslint-config/configs/unicorn.ts
 init_cjs_shims();
-async function unicorn(options = {}) {
+function unicorn() {
   return [
     {
       name: "solvro/unicorn/rules",
       plugins: {
         unicorn: import_eslint_plugin_unicorn.default
       },
-      rules: {
-        ...options.allRecommended ? import_eslint_plugin_unicorn.default.configs["flat/recommended"].rules : {
-          "unicorn/consistent-empty-array-spread": "error",
-          "unicorn/error-message": "error",
-          "unicorn/escape-case": "error",
-          "unicorn/new-for-builtins": "error",
-          "unicorn/no-instanceof-array": "error",
-          "unicorn/no-new-array": "error",
-          "unicorn/no-new-buffer": "error",
-          "unicorn/number-literal-case": "error",
-          "unicorn/prefer-dom-node-text-content": "error",
-          "unicorn/prefer-includes": "error",
-          "unicorn/prefer-node-protocol": "error",
-          "unicorn/prefer-number-properties": "error",
-          "unicorn/prefer-string-starts-ends-with": "error",
-          "unicorn/prefer-type-error": "error",
-          "unicorn/throw-new-error": "error"
-        }
-      }
+      rules: import_eslint_plugin_unicorn.default.configs["flat/recommended"].rules
     }
   ];
 }
 
-// eslint-config/factory.ts
-var flatConfigProps = [
-  "name",
-  "languageOptions",
-  "linterOptions",
-  "processor",
-  "plugins",
-  "rules",
-  "settings"
-];
-function solvro(options = {}, ...userConfigs) {
-  const {
-    componentExts = [],
-    gitignore: enableGitignore = true,
-    jsx: enableJsx = true,
-    react: enableReact = false,
-    regexp: enableRegexp = true,
-    typescript: enableTypeScript = (0, import_local_pkg3.isPackageExists)("typescript"),
-    unicorn: enableUnicorn = true
-  } = options;
-  let isInEditor = options.isInEditor;
-  if (isInEditor == null) {
-    isInEditor = isInEditorEnv();
-    if (isInEditor)
-      console.log(
-        "[@solvro/config] Detected running in editor, some rules are disabled."
-      );
-  }
-  const configs2 = [];
-  if (enableGitignore) {
-    if (typeof enableGitignore !== "boolean") {
-      configs2.push(
-        interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
-          r({
-            name: "solvro/gitignore",
-            ...enableGitignore
-          })
-        ])
-      );
-    } else {
-      configs2.push(
-        interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
-          r({
-            name: "solvro/gitignore",
-            strict: false
-          })
-        ])
-      );
-    }
-  }
-  const typescriptOptions = resolveSubOptions(options, "typescript");
-  const tsconfigPath = "tsconfigPath" in typescriptOptions ? typescriptOptions.tsconfigPath : void 0;
-  configs2.push(
-    ignores(options.ignores),
-    javascript({
-      isInEditor,
-      overrides: getOverrides(options, "javascript")
-    }),
-    comments(),
-    node(),
-    jsdoc(),
-    imports(),
-    command()
-  );
-  if (enableUnicorn) {
-    configs2.push(unicorn(enableUnicorn === true ? {} : enableUnicorn));
-  }
-  if (enableJsx) {
-    configs2.push(jsx());
-  }
-  if (enableTypeScript) {
-    configs2.push(
-      typescript({
-        ...typescriptOptions,
-        componentExts,
-        overrides: getOverrides(options, "typescript"),
-        type: options.type
-      })
-    );
-  }
-  if (enableRegexp) {
-    configs2.push(regexp(typeof enableRegexp === "boolean" ? {} : enableRegexp));
-  }
-  if (options.test ?? true) {
-    configs2.push(
-      test({
-        isInEditor,
-        overrides: getOverrides(options, "test")
-      })
-    );
-  }
-  if (enableReact) {
-    configs2.push(
-      react({
-        ...typescriptOptions,
-        overrides: getOverrides(options, "react"),
-        tsconfigPath
-      })
-    );
-  }
-  if (options.markdown ?? true) {
-    configs2.push(
-      markdown({
-        componentExts,
-        overrides: getOverrides(options, "markdown")
-      })
-    );
-  }
-  if (options.formatters) {
-    configs2.push(formatters());
-  }
-  configs2.push(disables());
-  if ("files" in options) {
-    throw new Error(
-      '[@solvro/config] The first argument should not contain the "files" property as the options are supposed to be global. Place it in the second or later config instead.'
-    );
-  }
-  const fusedConfig = flatConfigProps.reduce((acc, key) => {
-    if (key in options) acc[key] = options[key];
-    return acc;
-  }, {});
-  if (Object.keys(fusedConfig).length) configs2.push([fusedConfig]);
-  let composer = new import_eslint_flat_config_utils.FlatConfigComposer();
-  composer = composer.append(...configs2, ...userConfigs);
-  return composer;
-}
-function resolveSubOptions(options, key) {
-  return typeof options[key] === "boolean" ? {} : options[key] || {};
-}
-function getOverrides(options, key) {
-  const sub = resolveSubOptions(options, key);
-  return {
-    ...options.overrides?.[key],
-    ..."overrides" in sub ? sub.overrides : {}
-  };
-}
-
-// eslint-config/types.ts
-init_cjs_shims();
-
 // eslint-config/index.ts
-var eslint_config_default = solvro;
+var solvro = (...configs) => import_typescript_eslint2.default.config(
+  ...react(),
+  ...typescript(),
+  ...javascript(),
+  ...jsdoc(),
+  ...unicorn(),
+  ...disables(),
+  ...imports(),
+  ...comments(),
+  ...ignores(),
+  ...formatters(),
+  ...node(),
+  ...configs
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  GLOB_ALL_SRC,
-  GLOB_EXCLUDE,
-  GLOB_HTML,
-  GLOB_JS,
-  GLOB_JSON,
-  GLOB_JSON5,
-  GLOB_JSX,
-  GLOB_MARKDOWN,
-  GLOB_MARKDOWN_CODE,
-  GLOB_MARKDOWN_IN_MARKDOWN,
-  GLOB_SRC,
-  GLOB_SRC_EXT,
-  GLOB_STYLE,
-  GLOB_SVG,
-  GLOB_TESTS,
-  GLOB_TOML,
-  GLOB_TS,
-  GLOB_TSX,
-  GLOB_XML,
-  combine,
-  command,
-  comments,
-  disables,
-  ensurePackages,
-  formatters,
-  getOverrides,
-  ignores,
-  imports,
-  interopDefault,
-  isInEditorEnv,
-  isInGitHooksOrLintStaged,
-  isPackageInScope,
-  javascript,
-  jsdoc,
-  jsx,
-  markdown,
-  node,
-  parserPlain,
-  react,
-  regexp,
-  resolveSubOptions,
-  solvro,
-  test,
-  toArray,
-  typescript,
-  unicorn
+  solvro
 });
+//# sourceMappingURL=index.cjs.map