feat(linter): Handle config docs for string/enum values and add config option docs for various rules. (#15759)

This allows rules like `return-await` to render their possible values accurately on the docs website. Fixes #15078. Also part of #14743.

Used GitHub Copilot + Claude Sonnet 4.5 for most of the json schema edits, after figuring out which parts needed modification to enable this.

Updates the following rules with config option docs and uses DefaultRuleConfig for configuration handling:
- `react/prefer-es6-class`
- `unicorn/switch-case-braces`
- `vue/define-emits-declaration`
- `vue/define-props-declaration`
- `typescript/consistent-indexed-object-style`

Generated docs are as follows.

For `typescript/consistent-indexed-object-style`:
```md
## Configuration

This rule accepts one of the following string values:

### `"record"`

When set to `record`, enforces the use of a `Record` for indexed object types, e.g. `Record<string, unknown>`.

### `"index-signature"`

When set to `index-signature`, enforces the use of indexed signature types, e.g. `{ [key: string]: unknown }`.
```

For `typescript/return-await`:

```md
## Configuration

This rule accepts one of the following string values:

### `"in-try-catch"`

Require `await` when returning Promises inside try/catch/finally blocks.
This ensures proper error handling and stack traces.

### `"always"`

Require `await` before returning Promises in all cases.
Example: `return await Promise.resolve()` is required.

### `"error-handling-correctness-only"`

Require `await` only when it affects error handling correctness.
Only flags cases where omitting await would change error handling behavior.

### `"never"`

Disallow `await` before returning Promises in all cases.
Example: `return Promise.resolve()` is required (no await).
```

For `vue/define-emits-declaration`:

```md
## Configuration

This rule accepts one of the following string values:

### `"type-based"`

Enforce type-based declaration.

### `"type-literal"`

Enforce type-literal declaration.

### `"runtime"`

Enforce runtime declaration.
```

For `vue/define-props-declaration`:
```md
## Configuration

This rule accepts one of the following string values:

### `"type-based"`

Enforce type-based declaration.

### `"runtime"`

Enforce runtime declaration.
```

For `react/prefer-es6-class`:
```md
## Configuration

This rule accepts one of the following string values:

### `"always"`

Always prefer ES6 class-style components

### `"never"`

Do not allow ES6 class-style
```

Author: connorshea

crates/oxc_linter/src/rules/react/prefer_es6_class.rs

@@ -2,11 +2,13 @@ use oxc_ast::AstKind;
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 
 use crate::{
     AstNode,
     context::{ContextHost, LintContext},
-    rule::Rule,
+    rule::{DefaultRuleConfig, Rule},
     utils::{is_es5_component, is_es6_component},
 };
 
@@ -20,11 +22,19 @@ fn expected_es6_class_diagnostic(span: Span) -> OxcDiagnostic {
         .with_label(span)
 }
 
-#[derive(Debug, Default, Clone)]
-pub struct PreferEs6Class {
-    prefer_es6_class_option: PreferES6ClassOptionType,
+#[derive(Debug, Default, Clone, JsonSchema, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+enum PreferES6ClassOptionType {
+    /// Always prefer ES6 class-style components
+    #[default]
+    Always,
+    /// Do not allow ES6 class-style
+    Never,
 }
 
+#[derive(Debug, Default, Clone)]
+pub struct PreferEs6Class(PreferES6ClassOptionType);
+
 declare_oxc_lint!(
     /// ### What it does
     ///
@@ -48,30 +58,27 @@ declare_oxc_lint!(
     PreferEs6Class,
     react,
     style,
+    config = PreferES6ClassOptionType,
 );
 
 impl Rule for PreferEs6Class {
     fn from_configuration(value: serde_json::Value) -> Self {
-        let obj = value.get(0);
-
-        Self {
-            prefer_es6_class_option: obj
-                .and_then(serde_json::Value::as_str)
-                .map(PreferES6ClassOptionType::from)
-                .unwrap_or_default(),
-        }
+        Self(
+            serde_json::from_value::<DefaultRuleConfig<PreferES6ClassOptionType>>(value)
+                .unwrap_or_default()
+                .into_inner(),
+        )
     }
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         match node.kind() {
             AstKind::CallExpression(call_expr)
-                if matches!(self.prefer_es6_class_option, PreferES6ClassOptionType::Always)
-                    && is_es5_component(node) =>
+                if matches!(self.0, PreferES6ClassOptionType::Always) && is_es5_component(node) =>
             {
                 ctx.diagnostic(expected_es6_class_diagnostic(call_expr.callee.span()));
             }
             AstKind::Class(class_expr)
-                if !matches!(self.prefer_es6_class_option, PreferES6ClassOptionType::Always)
+                if !matches!(self.0, PreferES6ClassOptionType::Always)
                     && is_es6_component(node) =>
             {
                 ctx.diagnostic(unexpected_es6_class_diagnostic(
@@ -87,22 +94,6 @@ impl Rule for PreferEs6Class {
     }
 }
 
-#[derive(Debug, Default, Clone)]
-enum PreferES6ClassOptionType {
-    #[default]
-    Always,
-    Never,
-}
-
-impl PreferES6ClassOptionType {
-    pub fn from(raw: &str) -> Self {
-        match raw {
-            "always" => Self::Always,
-            _ => Self::Never,
-        }
-    }
-}
-
 #[test]
 fn test() {
     use crate::tester::Tester;

crates/oxc_linter/src/rules/typescript/consistent_indexed_object_style.rs

@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     AstNode,
     context::{ContextHost, LintContext},
-    rule::Rule,
+    rule::{DefaultRuleConfig, Rule},
 };
 
 fn consistent_indexed_object_style_diagnostic(
@@ -32,25 +32,16 @@ fn consistent_indexed_object_style_diagnostic(
     OxcDiagnostic::warn(warning_message).with_help(help_message).with_label(span)
 }
 
-#[derive(Debug, Clone, JsonSchema)]
-#[serde(rename_all = "camelCase", default)]
-pub struct ConsistentIndexedObjectStyle {
-    /// When set to `record`, enforces the use of a `Record` for indexed object types, e.g. `Record<string, unknown>`.
-    /// When set to `index-signature`, enforces the use of indexed signature types, e.g. `{ [key: string]: unknown }`.
-    preferred_style: ConsistentIndexedObjectStyleConfig,
-}
-
-impl Default for ConsistentIndexedObjectStyle {
-    fn default() -> Self {
-        Self { preferred_style: ConsistentIndexedObjectStyleConfig::Record }
-    }
-}
+#[derive(Debug, Clone, Default)]
+pub struct ConsistentIndexedObjectStyle(ConsistentIndexedObjectStyleConfig);
 
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 enum ConsistentIndexedObjectStyleConfig {
+    /// When set to `record`, enforces the use of a `Record` for indexed object types, e.g. `Record<string, unknown>`.
     #[default]
     Record,
+    /// When set to `index-signature`, enforces the use of indexed signature types, e.g. `{ [key: string]: unknown }`.
     IndexSignature,
 }
 
@@ -113,25 +104,22 @@ declare_oxc_lint!(
     typescript,
     style,
     conditional_fix,
-    config = ConsistentIndexedObjectStyle,
+    config = ConsistentIndexedObjectStyleConfig,
 );
 
 impl Rule for ConsistentIndexedObjectStyle {
     fn from_configuration(value: serde_json::Value) -> Self {
-        let config = value.get(0).and_then(serde_json::Value::as_str).map_or_else(
-            ConsistentIndexedObjectStyleConfig::default,
-            |value| match value {
-                "record" => ConsistentIndexedObjectStyleConfig::Record,
-                _ => ConsistentIndexedObjectStyleConfig::IndexSignature,
-            },
-        );
-        Self { preferred_style: config }
+        Self(
+            serde_json::from_value::<DefaultRuleConfig<ConsistentIndexedObjectStyleConfig>>(value)
+                .unwrap_or_default()
+                .into_inner(),
+        )
     }
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        let preferred_style = self.preferred_style;
+        let preferred_style = self.0;
 
-        if self.preferred_style == ConsistentIndexedObjectStyleConfig::Record {
+        if self.0 == ConsistentIndexedObjectStyleConfig::Record {
             match node.kind() {
                 AstKind::TSInterfaceDeclaration(inf) => {
                     if inf.body.body.len() > 1 {

crates/oxc_linter/src/rules/unicorn/switch_case_braces.rs

@@ -2,8 +2,15 @@ use oxc_ast::{AstKind, ast::Statement};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 
-use crate::{AstNode, ast_util::get_preceding_indent_str, context::LintContext, rule::Rule};
+use crate::{
+    AstNode,
+    ast_util::get_preceding_indent_str,
+    context::LintContext,
+    rule::{DefaultRuleConfig, Rule},
+};
 
 fn switch_case_braces_diagnostic_empty_clause(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Unexpected braces in empty case clause.")
@@ -24,16 +31,24 @@ fn switch_case_braces_diagnostic_unnecessary_braces(span: Span) -> OxcDiagnostic
 }
 
 #[derive(Debug, Clone)]
-pub struct SwitchCaseBraces {
-    always_braces: bool,
-}
+pub struct SwitchCaseBraces(Box<SwitchCaseBracesConfig>);
 
 impl Default for SwitchCaseBraces {
     fn default() -> Self {
-        Self { always_braces: true }
+        Self(Box::new(SwitchCaseBracesConfig::Always))
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum SwitchCaseBracesConfig {
+    /// Always require braces in case clauses (except empty cases).
+    #[default]
+    Always,
+    /// Allow braces only when needed for scoping (e.g., variable or function declarations).
+    Avoid,
+}
+
 declare_oxc_lint!(
     /// ### What it does
     ///
@@ -68,30 +83,24 @@ declare_oxc_lint!(
     /// }
     /// ```
     ///
-    /// ### Options
-    ///
-    /// `{ type: "always" | "avoid", default: "always" }`
-    ///
-    /// - `"always"`
-    ///   Always report when clause is not a `BlockStatement`.
-    ///
-    /// - `"avoid"`
-    ///   Allows braces only when needed for scoping (e.g., variable or function declarations).
-    ///
-    /// Example:
+    /// Example config:
     /// ```json
     /// "unicorn/switch-case-braces": ["error", "avoid"]
     /// ```
     SwitchCaseBraces,
     unicorn,
     style,
-    fix
+    fix,
+    config = SwitchCaseBracesConfig,
 );
 
 impl Rule for SwitchCaseBraces {
     fn from_configuration(value: serde_json::Value) -> Self {
-        let always_braces = value.get(0).is_none_or(|v| v.as_str() != Some("avoid"));
-        Self { always_braces }
+        Self(Box::new(
+            serde_json::from_value::<DefaultRuleConfig<SwitchCaseBracesConfig>>(value)
+                .unwrap_or_default()
+                .into_inner(),
+        ))
     }
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
@@ -116,7 +125,7 @@ impl Rule for SwitchCaseBraces {
                         );
                         continue;
                     }
-                    if !self.always_braces
+                    if *self.0 == SwitchCaseBracesConfig::Avoid
                         && !block_stmt.body.iter().any(|stmt| {
                             matches!(
                                 stmt,
@@ -141,7 +150,7 @@ impl Rule for SwitchCaseBraces {
                 _ => true,
             };
 
-            if self.always_braces && missing_braces {
+            if *self.0 == SwitchCaseBracesConfig::Always && missing_braces {
                 let test_end = case.test.as_ref().map_or(case.span.start, |t| t.span().end);
                 let colon_offset = ctx.find_next_token_from(test_end, ":").unwrap();
                 let colon_pos = test_end + colon_offset;

crates/oxc_linter/src/rules/vue/define_emits_declaration.rs

@@ -5,12 +5,14 @@ use oxc_ast::{
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 
 use crate::{
     AstNode,
     context::{ContextHost, LintContext},
     frameworks::FrameworkOptions,
-    rule::Rule,
+    rule::{DefaultRuleConfig, Rule},
 };
 
 fn has_arg_diagnostic(span: Span) -> OxcDiagnostic {
@@ -30,11 +32,18 @@ fn has_type_call_diagnostic(span: Span) -> OxcDiagnostic {
     .with_label(span)
 }
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, JsonSchema, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
 enum DeclarationStyle {
+    /// Enforces the use of a named TypeScript type or interface as the
+    /// argument to `defineEmits`, e.g. `defineEmits<MyEmits>()`.
     #[default]
     TypeBased,
+    /// Enforces the use of an inline type literal as the argument to
+    /// `defineEmits`, e.g. `defineEmits<{ (event: string): void }>()`.
     TypeLiteral,
+    /// Enforces the use of runtime declaration, where emits are declared
+    /// using an array or object, e.g. `defineEmits(['event1', 'event2'])`.
     Runtime,
 }
 
@@ -111,31 +120,22 @@ declare_oxc_lint!(
     /// });
     /// </script>
     /// ```
-    ///
-    /// ### Options
-    ///
-    /// ```
-    /// "vue/define-emits-declaration": ["error", "type-based" | "type-literal" | "runtime"]
-    /// ```
-    ///
-    /// - `type-based` (default): Enforce type-based declaration
-    /// - `type-literal`: Enforce type-literal declaration
-    /// - `runtime`: Enforce runtime declaration
     DefineEmitsDeclaration,
     vue,
     style,
-    pending  // TODO: transform it to the other declaration (if possible)
+    pending, // TODO: transform it to the other declaration (if possible)
+    config = DeclarationStyle,
 );
 
 impl Rule for DefineEmitsDeclaration {
     fn from_configuration(value: serde_json::Value) -> Self {
-        let val = value.get(0).and_then(|v| v.as_str());
-        Self(match val {
-            Some("type-literal") => DeclarationStyle::TypeLiteral,
-            Some("runtime") => DeclarationStyle::Runtime,
-            _ => DeclarationStyle::TypeBased,
-        })
+        Self(
+            serde_json::from_value::<DefaultRuleConfig<DeclarationStyle>>(value)
+                .unwrap_or_default()
+                .into_inner(),
+        )
     }
+
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         let AstKind::CallExpression(call_expr) = node.kind() else { return };