@agilebot/eslint-config 0.6.0 → 0.7.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,1093 @@
+/**
+ * @license @agilebot/eslint-config v0.7.0-beta.1
+ *
+ * Copyright (c) Agilebot, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import {
+  DEFAULT_GLOBS,
+  DTS_GLOBS,
+  IGNORE_GLOBS,
+  JS_GLOBS,
+  TS_GLOBS,
+  VUE_GLOBS,
+  __dirname,
+  define_STANDARD_RULES_default
+} from "./chunk-XQZGZMJY.mjs";
+
+// src/factory/index.ts
+import assert from "node:assert";
+import { findTsconfigFiles } from "@agilebot/eslint-utils";
+import * as parserTs from "@typescript-eslint/parser";
+import * as parserVue from "vue-eslint-parser";
+
+// src/configs/env.ts
+import globals from "globals";
+function env() {
+  return {
+    name: "agilebot/env",
+    files: DEFAULT_GLOBS,
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+        ...globals.es2015,
+        ...globals.mocha,
+        ...globals.jest,
+        ...globals.jasmine
+      }
+    }
+  };
+}
+
+// src/configs/standard.ts
+import pluginImport from "eslint-plugin-import-x";
+import pluginNode from "eslint-plugin-n";
+import pluginPromise from "eslint-plugin-promise";
+import pluginTs from "@typescript-eslint/eslint-plugin";
+function standard() {
+  const standardRules = {};
+  const originalStdRules = (
+    // @ts-expect-error -- extracted rules from eslint-config-love
+    typeof define_STANDARD_RULES_default === "undefined" ? {} : (
+      // @ts-expect-error -- extracted rules from eslint-config-love
+      define_STANDARD_RULES_default
+    )
+  );
+  const disabledRules = new Set(Object.values(standardDisabled()).flat());
+  Object.entries(originalStdRules).forEach(([key, value]) => {
+    if (disabledRules.has(key)) {
+      return;
+    }
+    if (key.startsWith("import/")) {
+      standardRules[`import-x/${key.slice(7)}`] = value;
+    } else {
+      standardRules[key] = value;
+    }
+  });
+  return {
+    name: "agilebot/standard",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      n: pluginNode,
+      "@typescript-eslint": pluginTs,
+      promise: pluginPromise,
+      "import-x": pluginImport
+    },
+    rules: {
+      ...standardRules,
+      "no-alert": "error",
+      // 找出TODO注释，以便后期修复
+      "no-warning-comments": [
+        "warn",
+        {
+          terms: ["todo", "fixme"]
+        }
+      ],
+      // 避免使用同步方法
+      "n/no-sync": "error",
+      // 尽量使用fs.promises而不是fs
+      "n/prefer-promises/fs": "error",
+      "n/prefer-promises/dns": "error",
+      // 路径拼接使用path.join，而不是直接使用加号
+      "n/no-path-concat": "error",
+      "promise/no-return-wrap": "error",
+      "promise/no-nesting": "error",
+      "promise/no-promise-in-callback": "error",
+      "promise/no-callback-in-promise": "error",
+      "promise/param-names": "error",
+      "promise/valid-params": "error",
+      "promise/no-multiple-resolved": "error",
+      "promise/no-return-in-finally": "error",
+      "promise/prefer-await-to-then": "warn",
+      // 自定义standard规则
+      "@typescript-eslint/max-params": ["error", { max: 5 }],
+      "@typescript-eslint/only-throw-error": [
+        "error",
+        {
+          allowThrowingAny: true,
+          allowThrowingUnknown: true
+        }
+      ],
+      "@typescript-eslint/no-loop-func": "warn"
+    }
+  };
+}
+function standardDisabled() {
+  return {
+    uncategoized: [
+      "@typescript-eslint/no-extraneous-class",
+      "@typescript-eslint/consistent-type-assertions",
+      "@typescript-eslint/no-non-null-assertion"
+    ],
+    "v9.0.0": ["@typescript-eslint/strict-boolean-expressions"],
+    "v10.0.0": ["@typescript-eslint/explicit-function-return-type"],
+    "v12.0.0": [
+      "@typescript-eslint/restrict-template-expressions",
+      "@typescript-eslint/space-before-function-paren"
+    ],
+    "v17.0.0": [
+      "@typescript-eslint/no-invalid-void-type",
+      "@typescript-eslint/method-signature-style"
+    ],
+    "v26.0.0": ["@typescript-eslint/no-confusing-void-expression"],
+    "v40.0.0": ["@typescript-eslint/unbound-method"],
+    "v42.0.0": ["@typescript-eslint/no-unsafe-argument"],
+    "v55.0.0": ["@typescript-eslint/class-methods-use-this"],
+    "v57.0.0": [
+      "@typescript-eslint/init-declarations",
+      "@typescript-eslint/no-empty-function"
+    ],
+    "v58.0.0": ["@typescript-eslint/no-explicit-any"],
+    "v64.0.0": ["@typescript-eslint/no-deprecated"],
+    "v65.0.0": ["@typescript-eslint/no-magic-numbers"],
+    "v70.0.0": ["@typescript-eslint/no-unnecessary-condition"],
+    "v75.0.0": ["@typescript-eslint/no-unnecessary-type-parameters"],
+    "v76.0.0": ["@typescript-eslint/no-unsafe-assignment"],
+    "v77.0.0": ["@typescript-eslint/no-unsafe-call"],
+    "v79.0.0": ["@typescript-eslint/no-unsafe-enum-comparison"],
+    "v80.0.0": ["@typescript-eslint/no-unsafe-member-access"],
+    "v81.0.0": ["@typescript-eslint/no-unsafe-return"],
+    "v82.0.0": ["@typescript-eslint/no-unsafe-unary-minus"],
+    "v89.0.0": ["@typescript-eslint/prefer-destructuring"]
+  };
+}
+
+// src/configs/ts.ts
+import { isInEditor } from "@agilebot/eslint-utils";
+import * as pluginTs2 from "@typescript-eslint/eslint-plugin";
+import pluginStylistic from "@stylistic/eslint-plugin";
+import pluginPreferArrowFunctions from "eslint-plugin-prefer-arrow-functions";
+import pluginUnusedImports from "eslint-plugin-unused-imports";
+function ts() {
+  return {
+    name: "agilebot/ts",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      "@typescript-eslint": pluginTs2,
+      "@stylistic": pluginStylistic,
+      "prefer-arrow-functions": pluginPreferArrowFunctions,
+      "unused-imports": pluginUnusedImports
+    },
+    rules: {
+      // 如果没用模板字符串，避免使用反引号
+      "@stylistic/quotes": ["error", "single", { avoidEscape: true }],
+      "prefer-arrow-functions/prefer-arrow-functions": [
+        "warn",
+        {
+          allowNamedFunctions: true,
+          classPropertiesAllowed: false,
+          disallowPrototype: false,
+          returnStyle: "unchanged",
+          singleReturnOnly: false
+        }
+      ],
+      "@typescript-eslint/no-unused-vars": "off",
+      "unused-imports/no-unused-imports": isInEditor() ? "off" : "error",
+      "unused-imports/no-unused-vars": [
+        "warn",
+        {
+          args: "after-used",
+          argsIgnorePattern: "^_",
+          vars: "all",
+          varsIgnorePattern: "^_",
+          caughtErrors: "none",
+          caughtErrorsIgnorePattern: "^_",
+          destructuredArrayIgnorePattern: "^_",
+          ignoreRestSiblings: true
+        }
+      ],
+      // 优先使用interface而不是type
+      "@typescript-eslint/consistent-type-definitions": "error",
+      "@typescript-eslint/naming-convention": [
+        "error",
+        // variable规则在@agilebot/var-naming中定义
+        {
+          selector: "function",
+          format: ["camelCase", "PascalCase"]
+        },
+        {
+          selector: "variable",
+          types: ["function"],
+          format: ["camelCase", "PascalCase"]
+        },
+        {
+          selector: "typeLike",
+          format: ["PascalCase"]
+        },
+        {
+          selector: "parameter",
+          format: ["camelCase"],
+          leadingUnderscore: "allow"
+        },
+        {
+          selector: "method",
+          format: ["camelCase"]
+        },
+        {
+          selector: "classProperty",
+          format: ["camelCase", "UPPER_CASE", "PascalCase"],
+          leadingUnderscore: "allow"
+        },
+        {
+          selector: "typeProperty",
+          format: ["camelCase"]
+        },
+        {
+          selector: "enum",
+          format: ["PascalCase"]
+        },
+        {
+          selector: "enumMember",
+          format: ["PascalCase", "UPPER_CASE"]
+        }
+      ],
+      // 禁止没有必要的初始化
+      "@typescript-eslint/no-inferrable-types": "error",
+      // 函数中未使用await，函数签名不要加async
+      "@typescript-eslint/require-await": "error",
+      // 没有必要的类型as
+      "@typescript-eslint/no-unnecessary-type-assertion": "error",
+      // 数组用T[]而不是Array<T>
+      "@typescript-eslint/array-type": ["error", { default: "array" }],
+      // Promise必须加await或void
+      "@typescript-eslint/no-misused-promises": [
+        "error",
+        {
+          checksVoidReturn: false
+        }
+      ],
+      "@typescript-eslint/no-deprecated": "error"
+    }
+  };
+}
+function tsOnly() {
+  return {
+    name: "agilebot/ts-only",
+    files: TS_GLOBS,
+    rules: {
+      "prefer-object-has-own": "error",
+      "@typescript-eslint/explicit-member-accessibility": "error"
+    }
+  };
+}
+function jsOnly() {
+  return {
+    name: "agilebot/js-only",
+    files: JS_GLOBS,
+    rules: {
+      "@typescript-eslint/no-require-imports": "off"
+    }
+  };
+}
+function dts() {
+  return {
+    name: "agilebot/dts",
+    files: DTS_GLOBS,
+    rules: {
+      // .d.ts中支持导入ts文件中的类型
+      "@typescript-eslint/consistent-type-imports": "off",
+      // .d.ts中忽略属性命名规则
+      "@typescript-eslint/naming-convention": "off",
+      // .d.ts中忽略三斜线引用
+      "@typescript-eslint/triple-slash-reference": "off"
+    }
+  };
+}
+
+// src/configs/imports.ts
+import path from "node:path";
+import fs from "node:fs";
+import { findCacheDir, findRootDir, isInEditor as isInEditor2 } from "@agilebot/eslint-utils";
+import pluginImport2 from "eslint-plugin-import-x";
+import pluginNoRelativeImportPaths from "eslint-plugin-no-relative-import-paths";
+function imports(opts) {
+  const rootDir = findRootDir(__dirname);
+  const pkgPath = path.join(opts.packageDir, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    throw new Error(`package.json not found in ${opts.packageDir}`);
+  }
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  const tmpPkg = {
+    name: `${pkg.name}/tmp`,
+    dependencies: {
+      [pkg.name]: "*"
+    }
+  };
+  const tmpPkgSafeName = tmpPkg.name.replace(/\//g, "__");
+  const cacheDir = findCacheDir(rootDir);
+  const tmpPkgDir = path.join(cacheDir, "tmp-pkg", tmpPkgSafeName);
+  if (!fs.existsSync(tmpPkgDir)) {
+    fs.mkdirSync(tmpPkgDir, { recursive: true });
+  }
+  const tmpPkgJson = JSON.stringify(tmpPkg, null, 2);
+  fs.writeFileSync(path.join(tmpPkgDir, "package.json"), tmpPkgJson);
+  return {
+    name: "agilebot/imports",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      "import-x": pluginImport2,
+      "no-relative-import-paths": pluginNoRelativeImportPaths
+    },
+    rules: {
+      ...pluginImport2.configs.recommended.rules,
+      ...pluginImport2.configs.typescript.rules,
+      "import-x/no-unresolved": [
+        "error",
+        {
+          ignore: [
+            String.raw`\?(react|raw|url|inline|worker|worker&inline|worker&url|sharedworker|sharedworker&inline|sharedworker&url)$`
+          ]
+        }
+      ],
+      "import-x/no-named-as-default-member": "off",
+      "import-x/no-named-as-default": "off",
+      "import-x/no-useless-path-segments": [
+        "error",
+        {
+          noUselessIndex: true
+        }
+      ],
+      "import-x/no-cycle": isInEditor2() ? "off" : "error",
+      "import-x/newline-after-import": "error",
+      "import-x/first": "error",
+      "import-x/no-import-module-exports": "error",
+      "import-x/no-anonymous-default-export": [
+        "error",
+        {
+          allowArray: true,
+          allowObject: true
+        }
+      ],
+      "import-x/no-extraneous-dependencies": [
+        "error",
+        {
+          packageDir: [opts.packageDir, tmpPkgDir, rootDir],
+          devDependencies: [
+            "test/**/*",
+            "tests/**/*",
+            "**/__tests__/**",
+            "**/*.test.{ts,tsx,js,jsx,cjs,mjs,mts,cts}",
+            "**/*.config.{ts,js,cjs,mjs,mts,cts}",
+            "**/.storybook/**",
+            "**/*.stories.{ts,tsx}",
+            "**/scripts/*.{ts,mts}",
+            ...opts.devDependencies ?? []
+          ],
+          includeInternal: true
+        }
+      ],
+      "import-x/order": [
+        "error",
+        {
+          groups: [
+            "builtin",
+            "external",
+            "internal",
+            "parent",
+            "sibling",
+            "index",
+            "object"
+          ],
+          pathGroups: [
+            {
+              pattern: `${pkg.name}/**`,
+              group: "parent",
+              position: "after"
+            }
+          ],
+          "newlines-between": "never",
+          distinctGroup: false
+        }
+      ],
+      "no-relative-import-paths/no-relative-import-paths": [
+        "warn",
+        { allowSameFolder: true }
+      ]
+    },
+    settings: {
+      "import-x/parsers": {
+        "@typescript-eslint/parser": [".ts", ".tsx"]
+      },
+      "import-x/resolver": opts.resolver === "oxc" ? {
+        oxc: true
+      } : {
+        typescript: {
+          alwaysTryTypes: true
+        }
+      },
+      "import-x/internal-regex": opts.monorepoScope ? `^${opts.monorepoScope.replace(/\//g, "")}/` : void 0,
+      "import-x/core-modules": opts.coreModules ?? void 0
+    }
+  };
+}
+
+// src/configs/unicorn.ts
+import pluginUnicorn from "eslint-plugin-unicorn";
+function unicorn(opts) {
+  return {
+    name: "agilebot/unicorn",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      unicorn: pluginUnicorn
+    },
+    rules: {
+      ...pluginUnicorn.configs["flat/recommended"].rules,
+      "unicorn/prefer-module": opts.module ? "error" : "off",
+      "unicorn/prefer-top-level-await": "off",
+      "unicorn/filename-case": "off",
+      "unicorn/import-style": "off",
+      "unicorn/prefer-at": "off",
+      "unicorn/prevent-abbreviations": "off",
+      "unicorn/prefer-date-now": "off",
+      "unicorn/no-process-exit": "off",
+      "unicorn/no-null": "off",
+      "unicorn/consistent-function-scoping": "off",
+      "unicorn/numeric-separators-style": "off",
+      "unicorn/prefer-optional-catch-binding": "off",
+      "unicorn/no-negated-condition": "off",
+      "unicorn/switch-case-braces": "off",
+      "unicorn/no-array-for-each": "off",
+      "unicorn/prefer-ternary": "off",
+      "unicorn/better-regex": "off",
+      "unicorn/error-message": "off",
+      "unicorn/no-object-as-default-parameter": "off",
+      "unicorn/no-array-push-push": "off",
+      "unicorn/no-useless-undefined": "off",
+      "unicorn/prefer-blob-reading-methods": "off",
+      "unicorn/catch-error-name": [
+        "error",
+        {
+          name: "err"
+        }
+      ],
+      "unicorn/prefer-global-this": "off"
+    }
+  };
+}
+
+// src/configs/react.ts
+import pluginReact from "eslint-plugin-react";
+import pluginReactX from "@eslint-react/eslint-plugin";
+import pluginReactHooks from "eslint-plugin-react-hooks";
+import pluginJsxA11y from "eslint-plugin-jsx-a11y";
+import pluginStylistic2 from "@stylistic/eslint-plugin";
+import pluginAgilebot from "@agilebot/eslint-plugin";
+function react(opts) {
+  return {
+    name: "agilebot/react",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      react: pluginReact,
+      "react-hooks": pluginReactHooks,
+      "jsx-a11y": pluginJsxA11y,
+      ...pluginReactX.configs.recommended.plugins,
+      "@stylistic": pluginStylistic2,
+      "@agilebot": pluginAgilebot
+    },
+    rules: {
+      ...pluginJsxA11y.flatConfigs.recommended.rules,
+      // recommended rules from eslint-plugin-react
+      "react/no-is-mounted": "error",
+      // recommended rules from @eslint-react
+      "@eslint-react/no-direct-mutation-state": "error",
+      // Children API
+      // '@eslint-react/no-children-count': 'warn',
+      // '@eslint-react/no-children-for-each': 'warn',
+      // '@eslint-react/no-children-map': 'warn',
+      // '@eslint-react/no-children-only': 'warn',
+      "@eslint-react/no-children-prop": "error",
+      "@eslint-react/no-children-to-array": "warn",
+      "@eslint-react/no-clone-element": "warn",
+      "@eslint-react/no-class-component": "error",
+      "@eslint-react/no-string-refs": "error",
+      "@eslint-react/no-missing-key": "error",
+      "@eslint-react/no-array-index-key": "warn",
+      "@eslint-react/no-duplicate-key": "error",
+      "@eslint-react/no-comment-textnodes": "error",
+      "@eslint-react/no-component-will-mount": "error",
+      "@eslint-react/no-component-will-receive-props": "error",
+      "@eslint-react/no-component-will-update": "error",
+      "@eslint-react/no-unsafe-component-will-mount": "warn",
+      "@eslint-react/no-unsafe-component-will-receive-props": "warn",
+      "@eslint-react/no-unsafe-component-will-update": "warn",
+      // '@eslint-react/no-unstable-context-value': 'error',
+      // '@eslint-react/no-unstable-default-props': 'error',
+      "@eslint-react/ensure-forward-ref-using-ref": "warn",
+      "@eslint-react/no-create-ref": "error",
+      "@eslint-react/no-nested-components": "warn",
+      "@eslint-react/no-redundant-should-component-update": "error",
+      "@eslint-react/no-set-state-in-component-did-mount": "warn",
+      "@eslint-react/no-set-state-in-component-did-update": "warn",
+      "@eslint-react/no-set-state-in-component-will-update": "warn",
+      "@eslint-react/prefer-shorthand-boolean": "error",
+      "@eslint-react/no-access-state-in-setstate": "error",
+      "@eslint-react/prefer-shorthand-fragment": "error",
+      "@eslint-react/no-missing-component-display-name": "error",
+      "@eslint-react/no-prop-types": "error",
+      "@eslint-react/no-useless-fragment": [
+        "error",
+        { allowExpressions: true }
+      ],
+      "@eslint-react/jsx-uses-vars": "error",
+      "@eslint-react/jsx-no-duplicate-props": "error",
+      // recommended rules from @eslint-react/dom
+      "@eslint-react/dom/no-children-in-void-dom-elements": "error",
+      "@eslint-react/dom/no-unsafe-target-blank": "error",
+      "@eslint-react/dom/no-dangerously-set-innerhtml": "error",
+      "@eslint-react/dom/no-dangerously-set-innerhtml-with-children": "error",
+      "@eslint-react/dom/no-find-dom-node": "error",
+      "@eslint-react/dom/no-render-return-value": "error",
+      // recommended rules from @eslint-react/hooks-extra
+      "@eslint-react/hooks-extra/prefer-use-state-lazy-initialization": "warn",
+      // recommended rules react-hooks
+      "react-hooks/rules-of-hooks": "error",
+      // recommended rules from @eslint-react/naming-convention
+      "@eslint-react/naming-convention/component-name": "error",
+      "@eslint-react/naming-convention/use-state": "error",
+      // recommended rules from @eslint-react/web-api
+      "@eslint-react/web-api/no-leaked-interval": "warn",
+      "@eslint-react/web-api/no-leaked-timeout": "warn",
+      "@eslint-react/web-api/no-leaked-event-listener": "warn",
+      "@eslint-react/web-api/no-leaked-resize-observer": "warn",
+      // 以下是自定义规则
+      "react/jsx-handler-names": [
+        "error",
+        {
+          eventHandlerPrefix: "handle",
+          eventHandlerPropPrefix: "on",
+          checkLocalVariables: true
+        }
+      ],
+      "react/no-unused-prop-types": "error",
+      // Stylistic rules are not supported by @eslint-react. Use dprint or @stylistic instead.
+      "@stylistic/jsx-self-closing-comp": "error",
+      // <App prop={'Hello'} />没必要，使用<App prop="Hello" />
+      "@stylistic/jsx-curly-brace-presence": [
+        "error",
+        {
+          props: "never",
+          children: "never",
+          propElementValues: "always"
+        }
+      ],
+      "jsx-a11y/click-events-have-key-events": "off",
+      "jsx-a11y/no-static-element-interactions": "off",
+      "jsx-a11y/alt-text": "off"
+    },
+    settings: {
+      react: {
+        version: typeof opts.version === "string" ? opts.version : "detect"
+      }
+    }
+  };
+}
+function reactJsOnly() {
+  return {
+    name: "agilebot/react-js-only",
+    files: JS_GLOBS,
+    rules: {
+      // The following can be enforced by TypeScript, no need to implement them
+      "react/jsx-no-duplicate-props": "error",
+      "react/jsx-no-undef": "error",
+      "react/jsx-uses-react": "error",
+      "react/no-unescaped-entities": "error",
+      "react/no-unknown-property": "error",
+      "react/react-in-jsx-scope": "error",
+      "react/require-render-return": "error"
+    }
+  };
+}
+
+// src/configs/vue.ts
+import pluginVue from "eslint-plugin-vue";
+function vue(opts) {
+  return {
+    name: "agilebot/vue",
+    files: VUE_GLOBS,
+    plugins: {
+      vue: pluginVue
+    },
+    rules: {
+      ...opts.version === 3 ? pluginVue.configs["vue3-strongly-recommended"].rules : pluginVue.configs["strongly-recommended"].rules
+    }
+  };
+}
+
+// src/configs/jsdoc.ts
+import pluginJsdoc from "eslint-plugin-jsdoc";
+function jsdoc(opt) {
+  return {
+    name: "agilebot/jsdoc",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      jsdoc: pluginJsdoc
+    },
+    rules: {
+      ...opt.ts ? pluginJsdoc.configs["flat/recommended-typescript-error"].rules : pluginJsdoc.configs["flat/recommended-error"].rules,
+      // 禁止有空行
+      "jsdoc/no-blank-block-descriptions": "error",
+      "jsdoc/no-blank-blocks": "error",
+      // 每行注释都有星号
+      "jsdoc/require-asterisk-prefix": "error",
+      "jsdoc/check-tag-names": [
+        "error",
+        {
+          typed: opt.ts
+        }
+      ],
+      "jsdoc/require-returns": "off",
+      // @return注释不是很有必要
+      "jsdoc/require-returns-type": "off"
+    }
+  };
+}
+
+// src/configs/lodash.ts
+import pluginLodash from "eslint-plugin-you-dont-need-lodash-underscore";
+
+// ../../node_modules/.pnpm/@eslint+compat@1.2.3_eslint@9.15.0_jiti@2.3.3_/node_modules/@eslint/compat/dist/esm/index.js
+var removedMethodNames = /* @__PURE__ */ new Map([
+  ["getSource", "getText"],
+  ["getSourceLines", "getLines"],
+  ["getAllComments", "getAllComments"],
+  ["getDeclaredVariables", "getDeclaredVariables"],
+  ["getNodeByRangeIndex", "getNodeByRangeIndex"],
+  ["getCommentsBefore", "getCommentsBefore"],
+  ["getCommentsAfter", "getCommentsAfter"],
+  ["getCommentsInside", "getCommentsInside"],
+  ["getJSDocComment", "getJSDocComment"],
+  ["getFirstToken", "getFirstToken"],
+  ["getFirstTokens", "getFirstTokens"],
+  ["getLastToken", "getLastToken"],
+  ["getLastTokens", "getLastTokens"],
+  ["getTokenAfter", "getTokenAfter"],
+  ["getTokenBefore", "getTokenBefore"],
+  ["getTokenByRangeStart", "getTokenByRangeStart"],
+  ["getTokens", "getTokens"],
+  ["getTokensAfter", "getTokensAfter"],
+  ["getTokensBefore", "getTokensBefore"],
+  ["getTokensBetween", "getTokensBetween"]
+]);
+var fixedUpRuleReplacements = /* @__PURE__ */ new WeakMap();
+var fixedUpRules = /* @__PURE__ */ new WeakSet();
+var fixedUpPluginReplacements = /* @__PURE__ */ new WeakMap();
+var fixedUpPlugins = /* @__PURE__ */ new WeakSet();
+function fixupRule(ruleDefinition) {
+  if (fixedUpRuleReplacements.has(ruleDefinition)) {
+    return fixedUpRuleReplacements.get(ruleDefinition);
+  }
+  const isLegacyRule = typeof ruleDefinition === "function";
+  if (!isLegacyRule && fixedUpRules.has(ruleDefinition)) {
+    return ruleDefinition;
+  }
+  const originalCreate = isLegacyRule ? ruleDefinition : ruleDefinition.create.bind(ruleDefinition);
+  function ruleCreate(context) {
+    if ("getScope" in context) {
+      return originalCreate(context);
+    }
+    const sourceCode = context.sourceCode;
+    let currentNode = sourceCode.ast;
+    const newContext = Object.assign(Object.create(context), {
+      parserServices: sourceCode.parserServices,
+      /*
+       * The following methods rely on the current node in the traversal,
+       * so we need to add them manually.
+       */
+      getScope() {
+        return sourceCode.getScope(currentNode);
+      },
+      getAncestors() {
+        return sourceCode.getAncestors(currentNode);
+      },
+      markVariableAsUsed(variable) {
+        sourceCode.markVariableAsUsed(variable, currentNode);
+      }
+    });
+    for (const [
+      contextMethodName,
+      sourceCodeMethodName
+    ] of removedMethodNames) {
+      newContext[contextMethodName] = sourceCode[sourceCodeMethodName].bind(sourceCode);
+    }
+    Object.freeze(newContext);
+    const visitor = originalCreate(newContext);
+    for (const [methodName, method] of Object.entries(visitor)) {
+      if (methodName.startsWith("on")) {
+        visitor[methodName] = (...args) => {
+          currentNode = args[methodName === "onCodePathSegmentLoop" ? 2 : 1];
+          return method.call(visitor, ...args);
+        };
+        continue;
+      }
+      visitor[methodName] = (...args) => {
+        currentNode = args[0];
+        return method.call(visitor, ...args);
+      };
+    }
+    return visitor;
+  }
+  const newRuleDefinition = {
+    ...isLegacyRule ? void 0 : ruleDefinition,
+    create: ruleCreate
+  };
+  const { schema } = ruleDefinition;
+  if (schema) {
+    if (!newRuleDefinition.meta) {
+      newRuleDefinition.meta = { schema };
+    } else {
+      newRuleDefinition.meta = {
+        ...newRuleDefinition.meta,
+        // top-level `schema` had precedence over `meta.schema` so it's okay to overwrite `meta.schema` if it exists
+        schema
+      };
+    }
+  }
+  fixedUpRuleReplacements.set(ruleDefinition, newRuleDefinition);
+  fixedUpRules.add(newRuleDefinition);
+  return newRuleDefinition;
+}
+function fixupPluginRules(plugin) {
+  if (fixedUpPluginReplacements.has(plugin)) {
+    return fixedUpPluginReplacements.get(plugin);
+  }
+  if (fixedUpPlugins.has(plugin) || !plugin.rules) {
+    return plugin;
+  }
+  const newPlugin = {
+    ...plugin,
+    rules: Object.fromEntries(
+      Object.entries(plugin.rules).map(([ruleId, ruleDefinition]) => [
+        ruleId,
+        fixupRule(ruleDefinition)
+      ])
+    )
+  };
+  fixedUpPluginReplacements.set(plugin, newPlugin);
+  fixedUpPlugins.add(newPlugin);
+  return newPlugin;
+}
+
+// src/configs/lodash.ts
+function lodash() {
+  return {
+    // lodash一些方法可能影响性能，如forEach等，优先使用js的原生方法
+    name: "agilebot/lodash",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      "you-dont-need-lodash-underscore": fixupPluginRules(pluginLodash)
+    },
+    rules: {
+      ...pluginLodash.configs["all-warn"].rules,
+      "you-dont-need-lodash-underscore/throttle": "off"
+    }
+  };
+}
+
+// src/configs/comments.ts
+import pluginComments from "@eslint-community/eslint-plugin-eslint-comments";
+function comments() {
+  return {
+    name: "agilebot/comments",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      "@eslint-community/eslint-comments": pluginComments
+    },
+    rules: {
+      // 禁止未使用的eslint-disable注释
+      "@eslint-community/eslint-comments/no-unused-disable": "error",
+      // 禁止无限制的eslint-disable注释
+      "@eslint-community/eslint-comments/no-unlimited-disable": "error",
+      // 禁止重复的eslint-disable注释
+      "@eslint-community/eslint-comments/no-duplicate-disable": "error",
+      // 禁止聚合的eslint-enable注释
+      "@eslint-community/eslint-comments/no-aggregating-enable": "error",
+      // 须说明原因eslint-disable
+      "@eslint-community/eslint-comments/require-description": [
+        "error",
+        {
+          ignore: ["eslint-env", "exported", "global", "globals"]
+        }
+      ]
+    }
+  };
+}
+
+// src/configs/cspell.ts
+import pluginCSpell from "@cspell/eslint-plugin";
+function cspell(opts) {
+  return {
+    name: "agilebot/cspell",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      "@cspell": pluginCSpell
+    },
+    rules: {
+      "@cspell/spellchecker": [
+        "warn",
+        {
+          checkComments: false,
+          autoFix: false,
+          cspell: opts
+        }
+      ]
+    }
+  };
+}
+
+// src/configs/agilebot.ts
+import pluginAgilebot2 from "@agilebot/eslint-plugin";
+import pluginReactHooks2 from "eslint-plugin-react-hooks";
+function agilebot(opts) {
+  return {
+    name: "agilebot/agilebot",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      "@agilebot": pluginAgilebot2,
+      "react-hooks": pluginReactHooks2
+    },
+    rules: {
+      ...pluginAgilebot2.configs.recommended.rules,
+      "react-hooks/exhaustive-deps": "off",
+      "@agilebot/react-better-exhaustive-deps": "warn"
+    },
+    settings: {
+      "agilebot/project-root": opts.root,
+      "agilebot/monorepo-scope": opts.monorepoScope ? opts.monorepoScope.replace(/\//g, "") : void 0
+    }
+  };
+}
+
+// src/configs/prettier.ts
+import prettierRecommended from "eslint-plugin-prettier/recommended";
+import pluginPrettier from "eslint-plugin-prettier";
+function prettier() {
+  return {
+    name: "agilebot/prettier",
+    files: DEFAULT_GLOBS,
+    plugins: {
+      prettier: pluginPrettier
+    },
+    // Do not extends
+    // extends: ['plugin:prettier/recommended'],
+    rules: {
+      ...prettierRecommended.rules,
+      curly: "error",
+      "arrow-body-style": "off",
+      "prettier/prettier": [
+        "error",
+        {
+          endOfLine: "auto"
+        }
+      ]
+    }
+  };
+}
+
+// src/configs/godaddy.ts
+import configGodaddy from "eslint-config-godaddy";
+import js from "@eslint/js";
+import pluginMocha from "eslint-plugin-mocha";
+function godaddy() {
+  return {
+    name: "agilebot/godaddy",
+    files: DEFAULT_GLOBS,
+    languageOptions: {
+      parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: "module"
+      }
+    },
+    plugins: {
+      mocha: pluginMocha
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...configGodaddy.rules,
+      "quote-props": "off",
+      "linebreak-style": "off",
+      complexity: "off",
+      "max-statements": "off",
+      "id-length": "off",
+      "default-case": "off",
+      "valid-jsdoc": "off",
+      "generator-star-spacing": "off",
+      "max-params": "off",
+      "max-depth": "off",
+      "max-len": "off",
+      indent: "off",
+      "no-undefined": "off",
+      "no-process-env": "off",
+      "no-sync": "off",
+      "no-continue": "off",
+      "no-case-declarations": "off",
+      "callback-return": "off",
+      "unicorn/prefer-string-slice": "off",
+      "unicorn/prefer-string-replace-all": "off",
+      "new-cap": "off"
+    }
+  };
+}
+
+// src/factory/index.ts
+function factory(root, options) {
+  assert.ok(root, "root option is required");
+  const tsconfigFiles = findTsconfigFiles(root, {
+    absolute: true
+  });
+  const defaultOptions = {
+    jsdoc: true,
+    prettier: true,
+    lodash: true,
+    cspell: {},
+    import: true,
+    importResolver: "typescript"
+  };
+  options = {
+    ...defaultOptions,
+    ...options
+  };
+  if (options?.config) {
+    assert.ok(
+      Object.keys(options.config).every(
+        (key) => key === "rules" || key === "settings"
+      ),
+      "config option must only contain rules and settings"
+    );
+  }
+  const commonConfigs = [
+    unicorn({
+      module: options?.module ?? false
+    }),
+    comments()
+  ];
+  if (options.import) {
+    commonConfigs.push(
+      imports({
+        packageDir: root,
+        devDependencies: options?.devDependencies,
+        monorepoScope: options?.monorepoScope,
+        coreModules: options?.coreModules,
+        resolver: options?.importResolver
+      })
+    );
+  }
+  if (options.prettier) {
+    commonConfigs.push(prettier());
+  }
+  const config = [];
+  if (options.godaddy) {
+    config.push({
+      name: "agilebot/parser",
+      files: DEFAULT_GLOBS,
+      languageOptions: {
+        parser: options.godaddy === "typescript" ? parserTs : void 0,
+        parserOptions: {
+          project: tsconfigFiles.length > 0 ? tsconfigFiles : true
+        }
+      }
+    });
+    config.push(env());
+    if (options.jsdoc) {
+      config.push(
+        jsdoc({
+          ts: false
+        })
+      );
+    }
+    config.push(...commonConfigs);
+    config.push(godaddy());
+    if (options.config) {
+      config.push(options.config);
+    }
+  } else {
+    config.push({
+      name: "agilebot/parser",
+      files: DEFAULT_GLOBS,
+      languageOptions: {
+        parser: !options.vue ? parserTs : parserVue,
+        parserOptions: {
+          parser: parserTs,
+          tsconfigRootDir: root,
+          projectService: true,
+          project: tsconfigFiles.length > 0 ? tsconfigFiles : true,
+          ecmaFeatures: {
+            jsx: true
+          },
+          sourceType: options.module ? "module" : void 0,
+          extraFileExtensions: !options?.vue ? void 0 : [".vue"]
+        }
+      }
+    });
+    config.push(env());
+    config.push(standard());
+    config.push(ts());
+    config.push(jsOnly());
+    config.push(dts());
+    config.push(tsOnly());
+    if (options.react) {
+      config.push(react({ version: options.react }));
+      config.push(reactJsOnly());
+    }
+    if (options.vue) {
+      config.push(
+        vue({
+          version: options.vue
+        })
+      );
+    }
+    if (options.lodash) {
+      config.push(lodash());
+    }
+    if (options.cspell) {
+      config.push(cspell(options.cspell));
+    }
+    if (options.jsdoc) {
+      config.push({
+        ...jsdoc({
+          ts: true
+        }),
+        files: TS_GLOBS
+      });
+      config.push({
+        ...jsdoc({
+          ts: false
+        }),
+        files: JS_GLOBS
+      });
+    }
+    config.push(...commonConfigs);
+    config.push(
+      agilebot({
+        root,
+        monorepoScope: options?.monorepoScope
+      })
+    );
+    if (options.config) {
+      config.push(options.config);
+    }
+  }
+  config.push({
+    name: "agilebot/ignores",
+    ignores: [...IGNORE_GLOBS, ...options.ignores ?? []]
+  });
+  const includedPlugins = /* @__PURE__ */ new Set();
+  config.forEach((configItem) => {
+    if (configItem.plugins) {
+      Object.keys(configItem.plugins).forEach((pluginName) => {
+        if (includedPlugins.has(pluginName)) {
+          delete configItem.plugins[pluginName];
+        } else {
+          includedPlugins.add(pluginName);
+        }
+      });
+    }
+  });
+  return config;
+}
+export {
+  factory as agilebot
+};