+
+### What it does
+
+Enforces a maximum cyclomatic complexity in a program, which is the number
+of linearly independent paths in a program.
+
+### Why is this bad?
+
+Having high code complexity reduces code readability. This rule
+aims to make the code easier to follow by reducing the number of branches
+in the program.
+
+### Examples
+
+Examples of **incorrect** code for this rule with `{ "max": 2 }`
+
+```js
+function foo() {
+ if (foo1) {
+ return x1; // 1st path
+ } else if (foo2) {
+ return x2; // 2nd path
+ } else {
+ return x3; // 3rd path
+ }
+}
+
+function bar() {
+ // there are 2 paths - when bar1 is falsy, and when bar1 is truthy, in which bar1 = bar1 && bar2;
+ bar1 &&= bar2;
+ // there are 2 paths - when bar3 is truthy, and when bar3 is falsy, in which bar3 = 4;
+ bar3 ||= 4;
+}
+
+// there are 2 paths - when baz1 is defined, and when baz1 is undefined and is assigned 'a'
+function baz(baz1 = "a") {
+ const { baz2 = "b" } = baz3; // there are 2 additional paths - when baz2 is defined and when baz2 is not
+}
+
+function d() {
+ d1 = d2?.d3?.(); // optional chaining creates 2 paths each - when object is defined and when it is not
+}
+```
+
+Examples of **correct** code for this rule with `{ "max": 2 }`
+
+```js
+// This example is taken directly from ESLint documentation
+function foo() {
+ // this function has complexity = 1
+ class C {
+ x = a + b; // this initializer has complexity = 1
+ y = c || d; // this initializer has complexity = 2
+ z = e && f; // this initializer has complexity = 2
+
+ static p = g || h; // this initializer has complexity = 2
+ static q = i ? j : k; // this initializer has complexity = 2
+
+ static {
+ // this static block has complexity = 2
+ if (foo) {
+ baz = bar;
+ }
+ }
+
+ static {
+ // this static block has complexity = 2
+ qux = baz || quux;
+ }
+ }
+}
+```
+
+## Configuration
+
+This rule accepts a configuration object with the following properties:
+
+### max
+
+type: `integer`
+
+default: `20`
+
+Maximum amount of cyclomatic complexity
+
+### variant
+
+type: `"classic" | "modified"`
+
+default: `"classic"`
+
+The cyclomatic complexity variant to use
+
+#### `"classic"`
+
+Classic means McCabe cyclomatic complexity
+
+#### `"modified"`
+
+Modified means classic cyclomatic complexity but a switch statement increases
+complexity by 1 irrespective of the number of `case` statements
+
+## How to use
+
+To **enable** this rule using the config file or in the CLI, you can use:
+
+::: code-group
+
+```json [Config (.oxlintrc.json)]
+{
+ "rules": {
+ "complexity": "error"
+ }
+}
+```
+
+```bash [CLI]
+oxlint --deny complexity
+```
+
+:::
+
+## References
+
+- Rule Source
diff --git a/src/docs/guide/usage/linter/rules/eslint/no-nonoctal-decimal-escape.md b/src/docs/guide/usage/linter/rules/eslint/no-nonoctal-decimal-escape.md
index a29daf9cbc5..f2f485f7e89 100644
--- a/src/docs/guide/usage/linter/rules/eslint/no-nonoctal-decimal-escape.md
+++ b/src/docs/guide/usage/linter/rules/eslint/no-nonoctal-decimal-escape.md
@@ -12,7 +12,7 @@ const source = `https://github.com/oxc-project/oxc/blob/${ data }/crates/oxc_lin
✅ This rule is turned on by default.
-🚧 An auto-fix is planned for this rule, but not implemented at this time.
+💡 A suggestion is available for this rule.
diff --git a/src/docs/guide/usage/linter/rules/eslint/no-useless-escape.md b/src/docs/guide/usage/linter/rules/eslint/no-useless-escape.md
index b9eab782471..c4a44dafc67 100644
--- a/src/docs/guide/usage/linter/rules/eslint/no-useless-escape.md
+++ b/src/docs/guide/usage/linter/rules/eslint/no-useless-escape.md
@@ -31,8 +31,6 @@ This applies to string literals, template literals, and regular expressions.
Examples of **incorrect** code for this rule:
```javascript
-/*eslint no-useless-escape: "error"*/
-
"\'";
'\"';
"\#";
@@ -49,8 +47,6 @@ Examples of **incorrect** code for this rule:
Examples of **correct** code for this rule:
```javascript
-/*eslint no-useless-escape: "error"*/
-
"\"";
'\'';
"\x12";
@@ -79,6 +75,9 @@ type: `string[]`
default: `[]`
An array of characters that are allowed to be escaped unnecessarily in regexes.
+For example, setting this to `["#"]` allows `\#` in regexes.
+
+Each string in this array must be a single character.
## How to use
diff --git a/src/docs/guide/usage/linter/rules/eslint/prefer-destructuring.md b/src/docs/guide/usage/linter/rules/eslint/prefer-destructuring.md
index 67473a64e57..7cb3c4ea7b8 100644
--- a/src/docs/guide/usage/linter/rules/eslint/prefer-destructuring.md
+++ b/src/docs/guide/usage/linter/rules/eslint/prefer-destructuring.md
@@ -9,7 +9,7 @@ const source = `https://github.com/oxc-project/oxc/blob/${ data }/crates/oxc_lin
-🚧 An auto-fix is planned for this rule, but not implemented at this time.
+🛠️ An auto-fix is available for this rule.
+
+🚧 An auto-fix is planned for this rule, but not implemented at this time.
+
### What it does
diff --git a/src/docs/guide/usage/linter/rules/import/extensions.md b/src/docs/guide/usage/linter/rules/import/extensions.md
index b1ee0645c25..dd3b0200a56 100644
--- a/src/docs/guide/usage/linter/rules/import/extensions.md
+++ b/src/docs/guide/usage/linter/rules/import/extensions.md
@@ -84,45 +84,50 @@ This rule accepts three types of configuration:
1. **Global rule** (string): `"always"`, `"never"`, or `"ignorePackages"`
-```json
+```jsonc
{
"rules": {
- // this would require extensions for all imports
- "import/extensions": ["error", "always"]
- }
+ // this would require extensions for all imports, *including from packages*
+ // e.g. `import React from 'react';` would be disallowed.
+ // You should generally always set `ignorePackages` to `true` when using `always`.
+ "import/extensions": ["error", "always"],
+ },
}
```
2. **Per-extension rules** (object): `{ "js": "always", "jsx": "never", ... }`
-```json
+```jsonc
{
"rules": {
"import/extensions": [
"error",
// per-extension rules:
// require extensions for .js imports and disallow them for .ts imports
- { "js": "always", "ts": "never" }
- ]
- }
+ { "js": "always", "ts": "never", "ignorePackages": true },
+ ],
+ },
}
```
3. **Combined** (array): `["error", "always", { "js": "never" }]` or `["error", { "js": "always" }]`
-```json
+```jsonc
{
"rules": {
"import/extensions": [
"error",
"always", // by default, require extensions for all imports
- { "ts": "never" } // override the global value and disallow extensions on imports for specific file types
- ]
- }
+ {
+ "ts": "never", // override the global value and disallow extensions on imports for specific file types
+ "ignorePackages": true,
+ },
+ ],
+ },
}
```
-**Default behavior (no configuration)**: All imports pass.
+**Default behavior (no configuration)**: All imports - of all kinds - pass.
Unconfigured file extensions are ignored, to avoid false positives.
This rule accepts a configuration object with the following properties:
@@ -135,13 +140,12 @@ default: `false`
Whether to check type imports when enforcing extension rules.
-### extensions
-
-type: `Record`
-
-default: `{}`
-
-Map from file extension (without dot) to its configured rule.
+```ts
+// If checkTypeImports is `false`, we don't care about
+// whether these imports have file extensions or not, both are always allowed:
+import type { Foo } from "./foo";
+import type { Foo } from "./foo.ts";
+```
### ignorePackages
@@ -151,8 +155,15 @@ default: `false`
Whether to ignore package imports when enforcing extension rules.
+> [!IMPORTANT]
+> When setting this rule to `always`, you should also set `ignorePackages` to `true`.
+> Otherwise, package imports without extensions (such as `import React from 'react';`)
+> will be disallowed, which is not desirable and is not fixable.
+
A boolean option (not per-extension) that exempts package imports from the "always" rule.
+
Can be set in the config object: `["error", "always", { "ignorePackages": true }]`
+
Legacy shorthand: `["error", "ignorePackages"]` is equivalent to `["error", "always", { "ignorePackages": true }]`
- **With "always"**: When `true`, package imports (e.g., `lodash`, `@babel/core`) don't require extensions
@@ -172,6 +183,8 @@ Array of pattern-action pairs for custom import protocols (monorepo tools, custo
Each override has: `{ "pattern": "", "action": "enforce" | "ignore" }`
**Pattern matching**: Uses glob patterns (`*`, `**`, `{a,b}`) to match import specifiers.
+Note that the pattern matching is done in Rust with the fast-glob library, and so may differ
+from the JavaScript glob library used by the original ESLint rule.
**Actions**:
@@ -180,38 +193,21 @@ Each override has: `{ "pattern": "", "action": "enforce" | "ignore
**Precedence**: First matching pattern wins.
-Example: `["error", "always", { "pathGroupOverrides": [{ "pattern": "rootverse{*,*/**}", "action": "ignore" }] }]`
-
-- Allows `import { x } from 'rootverse+debug:src'` without extension
-- Still requires extensions for standard imports
-
-#### pathGroupOverrides[n]
-
-type: `object`
-
-Path group override configuration for bespoke import specifiers.
-
-Allows fine-grained control over extension validation for custom import protocols
-(e.g., monorepo tools, custom resolvers, framework-specific imports).
-
-**Pattern matching:**
-
-Uses fast-glob patterns to match import specifiers:
-
-- `*`: Match any characters except `/`
-- `**`: Match any characters including `/` (recursive)
-- `{a,b}`: Match alternatives
-
**Examples:**
```json
{
"pattern": "rootverse{*,*/**}",
- "action": "enforce"
+ "action": "ignore"
}
```
-Matches: `rootverse+debug:src`, `rootverse+bfe:src/symbols`
+Matches imports from `rootverse+debug:src`, `rootverse+bfe:src/symbols` and
+ignores whether or not they have an extension.
+
+#### pathGroupOverrides[n]
+
+type: `object`
##### pathGroupOverrides[n].action
@@ -223,17 +219,17 @@ Determines how import extensions are validated for matching bespoke import speci
###### `"enforce"`
-Enforce extension validation for matching imports (require extensions based on config)
+Enforce extension validation for matching imports (require extensions based on config).
###### `"ignore"`
-Ignore matching imports entirely (skip all extension validation)
+Ignore matching imports entirely (skip all extension validation).
##### pathGroupOverrides[n].pattern
type: `string`
-Glob pattern to match import specifiers
+Glob pattern to match import specifiers. This uses Rust's fast-glob library for matching.
## How to use
diff --git a/src/docs/guide/usage/linter/rules/jsx_a11y/aria-proptypes.md b/src/docs/guide/usage/linter/rules/jsx_a11y/aria-proptypes.md
new file mode 100644
index 00000000000..3b5eb4c242c
--- /dev/null
+++ b/src/docs/guide/usage/linter/rules/jsx_a11y/aria-proptypes.md
@@ -0,0 +1,63 @@
+
+
+
+
+# jsx_a11y/aria-proptypes
+
+
+
+
+### What it does
+
+Enforces that elements do not use invalid ARIA state and property values.
+
+### Why is this bad?
+
+Using invalid ARIA state and property values can mislead screen readers and other assistive technologies.
+It may cause the accessibility features of the website to fail, making it difficult for users with disabilities to use the site effectively.
+
+### Examples
+
+Examples of **incorrect** code for this rule:
+
+```jsx
+
+
+```
+
+Examples of **correct** code for this rule:
+
+```jsx
+
+
+
+
+```
+
+## How to use
+
+To **enable** this rule using the config file or in the CLI, you can use:
+
+::: code-group
+
+```json [Config (.oxlintrc.json)]
+{
+ "plugins": ["jsx-a11y"],
+ "rules": {
+ "jsx-a11y/aria-proptypes": "error"
+ }
+}
+```
+
+```bash [CLI]
+oxlint --deny jsx-a11y/aria-proptypes --jsx-a11y-plugin
+```
+
+:::
+
+## References
+
+- Rule Source
diff --git a/src/docs/guide/usage/linter/rules/jsx_a11y/mouse-events-have-key-events.md b/src/docs/guide/usage/linter/rules/jsx_a11y/mouse-events-have-key-events.md
index ddb72e772a4..85e12c2273c 100644
--- a/src/docs/guide/usage/linter/rules/jsx_a11y/mouse-events-have-key-events.md
+++ b/src/docs/guide/usage/linter/rules/jsx_a11y/mouse-events-have-key-events.md
@@ -12,7 +12,7 @@ const source = `https://github.com/oxc-project/oxc/blob/${ data }/crates/oxc_lin
### What it does
-Enforce onMouseOver/onMouseOut are accompanied by onFocus/onBlur.
+Enforce `onMouseOver`/`onMouseOut` are accompanied by `onFocus`/`onBlur`.
### Why is this bad?
diff --git a/src/docs/guide/usage/linter/rules/jsx_a11y/no-static-element-interactions.md b/src/docs/guide/usage/linter/rules/jsx_a11y/no-static-element-interactions.md
new file mode 100644
index 00000000000..cf680c0e1c2
--- /dev/null
+++ b/src/docs/guide/usage/linter/rules/jsx_a11y/no-static-element-interactions.md
@@ -0,0 +1,84 @@
+
+
+
+
+# jsx_a11y/no-static-element-interactions
+
+
+
+
+### What it does
+
+Enforces that static HTML elements with event handlers must have appropriate ARIA roles.
+
+### Why is this bad?
+
+Static HTML elements do not have semantic meaning in accessibility contexts.
+When these elements receive click or keyboard event handlers, they must declare a role
+to indicate their interactive purpose to assistive technologies.
+
+### Examples
+
+Examples of **incorrect** code for this rule:
+
+```jsx
+
{}} />
+
+```
+
+Examples of **correct** code for this rule:
+
+```jsx
+