@wistia/oxlint-config 0.2.0 → 0.3.0

package/rules/{base.jsonc → base.ts}

@@ -1,636 +1,633 @@
-{
-  "$schema": "../node_modules/oxlint/configuration_schema.json",
-  "plugins": ["eslint", "oxc"],
-  "categories": {},
-  "rules": {
+import type { RuleFile } from '../types.ts';
+
+export const baseRules = {
+  plugins: ['eslint', 'oxc'],
+  rules: {
     // -- Possible Problems (Correctness) --
 
     // Enforce return statements in callbacks of array methods
     // https://eslint.org/docs/rules/array-callback-return
-    "eslint/array-callback-return": ["error", { "allowImplicit": true }],
+    'eslint/array-callback-return': ['error', { allowImplicit: true }],
 
     // Require super() calls in constructors
     // https://eslint.org/docs/rules/constructor-super
-    "eslint/constructor-super": "error",
+    'eslint/constructor-super': 'error',
 
     // Enforce for loop update clause moving the counter in the right direction
     // https://eslint.org/docs/rules/for-direction
-    "eslint/for-direction": "error",
+    'eslint/for-direction': 'error',
 
     // Disallow using an async function as a Promise executor
     // https://eslint.org/docs/rules/no-async-promise-executor
-    "eslint/no-async-promise-executor": "error",
+    'eslint/no-async-promise-executor': 'error',
 
     // Disallow await inside of loops
     // https://eslint.org/docs/rules/no-await-in-loop
-    "eslint/no-await-in-loop": "error",
+    'eslint/no-await-in-loop': 'error',
 
     // Disallow reassigning class members
     // https://eslint.org/docs/rules/no-class-assign
-    "eslint/no-class-assign": "error",
+    'eslint/no-class-assign': 'error',
 
     // Disallow comparing against -0
     // https://eslint.org/docs/rules/no-compare-neg-zero
-    "eslint/no-compare-neg-zero": "error",
+    'eslint/no-compare-neg-zero': 'error',
 
     // Disallow assignment operators in conditional expressions
     // https://eslint.org/docs/rules/no-cond-assign
-    "eslint/no-cond-assign": ["error", "always"],
+    'eslint/no-cond-assign': ['error', 'always'],
 
     // Disallow reassigning const variables
     // https://eslint.org/docs/rules/no-const-assign
-    "eslint/no-const-assign": "error",
+    'eslint/no-const-assign': 'error',
 
     // Disallow expressions where the operation doesn't affect the value
     // https://eslint.org/docs/rules/no-constant-binary-expression
-    "eslint/no-constant-binary-expression": "error",
+    'eslint/no-constant-binary-expression': 'error',
 
     // Disallow constant expressions in conditions
     // https://eslint.org/docs/rules/no-constant-condition
-    "eslint/no-constant-condition": "error",
+    'eslint/no-constant-condition': 'error',
 
     // Disallow returning value from constructor
     // https://eslint.org/docs/rules/no-constructor-return
-    "eslint/no-constructor-return": "error",
+    'eslint/no-constructor-return': 'error',
 
     // Disallow control characters in regular expressions
     // https://eslint.org/docs/rules/no-control-regex
-    "eslint/no-control-regex": "error",
+    'eslint/no-control-regex': 'error',
 
     // Disallow the use of debugger
     // https://eslint.org/docs/rules/no-debugger
-    "eslint/no-debugger": "error",
+    'eslint/no-debugger': 'error',
 
     // Disallow duplicate class members
     // https://eslint.org/docs/rules/no-dupe-class-members
-    "eslint/no-dupe-class-members": "error",
+    'eslint/no-dupe-class-members': 'error',
 
     // Disallow duplicate conditions in if-else-if chains
     // https://eslint.org/docs/rules/no-dupe-else-if
-    "eslint/no-dupe-else-if": "error",
+    'eslint/no-dupe-else-if': 'error',
 
     // Disallow duplicate keys in object literals
     // https://eslint.org/docs/rules/no-dupe-keys
-    "eslint/no-dupe-keys": "error",
+    'eslint/no-dupe-keys': 'error',
 
     // Disallow duplicate case labels
     // https://eslint.org/docs/rules/no-duplicate-case
-    "eslint/no-duplicate-case": "error",
+    'eslint/no-duplicate-case': 'error',
 
     // Disallow empty character classes in regular expressions
     // https://eslint.org/docs/rules/no-empty-character-class
-    "eslint/no-empty-character-class": "error",
+    'eslint/no-empty-character-class': 'error',
 
     // Disallow empty destructuring patterns
     // https://eslint.org/docs/rules/no-empty-pattern
-    "eslint/no-empty-pattern": "error",
+    'eslint/no-empty-pattern': 'error',
 
     // Disallow reassigning exceptions in catch clauses
     // https://eslint.org/docs/rules/no-ex-assign
-    "eslint/no-ex-assign": "error",
+    'eslint/no-ex-assign': 'error',
 
     // Disallow fallthrough of case statements
     // https://eslint.org/docs/rules/no-fallthrough
-    "eslint/no-fallthrough": "error",
+    'eslint/no-fallthrough': 'error',
 
     // Disallow reassigning function declarations
     // https://eslint.org/docs/rules/no-func-assign
-    "eslint/no-func-assign": "error",
+    'eslint/no-func-assign': 'error',
 
     // Disallow assigning to imported bindings
     // https://eslint.org/docs/rules/no-import-assign
-    "eslint/no-import-assign": "error",
+    'eslint/no-import-assign': 'error',
 
     // Disallow variable or function declarations in nested blocks
     // https://eslint.org/docs/rules/no-inner-declarations
-    "eslint/no-inner-declarations": "error",
+    'eslint/no-inner-declarations': 'error',
 
     // Disallow invalid regular expression strings in RegExp constructors
     // https://eslint.org/docs/rules/no-invalid-regexp
-    "eslint/no-invalid-regexp": "error",
+    'eslint/no-invalid-regexp': 'error',
 
     // Disallow irregular whitespace
     // https://eslint.org/docs/rules/no-irregular-whitespace
-    "eslint/no-irregular-whitespace": "error",
+    'eslint/no-irregular-whitespace': 'error',
 
     // Disallow literal numbers that lose precision
     // https://eslint.org/docs/rules/no-loss-of-precision
-    "eslint/no-loss-of-precision": "error",
+    'eslint/no-loss-of-precision': 'error',
 
     // Disallow characters which are made with multiple code points in character class syntax
     // https://eslint.org/docs/rules/no-misleading-character-class
-    "eslint/no-misleading-character-class": "error",
+    'eslint/no-misleading-character-class': 'error',
 
     // Disallow new operators with global non-constructor functions
     // https://eslint.org/docs/rules/no-new-native-nonconstructor
-    "eslint/no-new-native-nonconstructor": "error",
+    'eslint/no-new-native-nonconstructor': 'error',
 
     // Disallow calling global object properties as functions
     // https://eslint.org/docs/rules/no-obj-calls
-    "eslint/no-obj-calls": "error",
+    'eslint/no-obj-calls': 'error',
 
     // Disallow returning values from Promise executor functions
     // https://eslint.org/docs/rules/no-promise-executor-return
-    "eslint/no-promise-executor-return": "error",
+    'eslint/no-promise-executor-return': 'error',
 
     // Disallow calling some Object.prototype methods directly on objects
     // https://eslint.org/docs/rules/no-prototype-builtins
-    "eslint/no-prototype-builtins": "error",
+    'eslint/no-prototype-builtins': 'error',
 
     // Disallow assignments where both sides are exactly the same
     // https://eslint.org/docs/rules/no-self-assign
-    "eslint/no-self-assign": "error",
+    'eslint/no-self-assign': 'error',
 
     // Disallow comparisons where both sides are exactly the same
     // https://eslint.org/docs/rules/no-self-compare
-    "eslint/no-self-compare": "error",
+    'eslint/no-self-compare': 'error',
 
     // Disallow returning values from setters
     // https://eslint.org/docs/rules/no-setter-return
-    "eslint/no-setter-return": "error",
+    'eslint/no-setter-return': 'error',
 
     // Disallow sparse arrays
     // https://eslint.org/docs/rules/no-sparse-arrays
-    "eslint/no-sparse-arrays": "error",
+    'eslint/no-sparse-arrays': 'error',
 
     // Disallow template literal placeholder syntax in regular strings
     // https://eslint.org/docs/rules/no-template-curly-in-string
-    "eslint/no-template-curly-in-string": "error",
+    'eslint/no-template-curly-in-string': 'error',
 
     // Disallow this/super before calling super() in constructors
     // https://eslint.org/docs/rules/no-this-before-super
-    "eslint/no-this-before-super": "error",
+    'eslint/no-this-before-super': 'error',
 
     // Disallow let or var variables that are read but never assigned
     // https://eslint.org/docs/rules/no-unassigned-vars
-    "eslint/no-unassigned-vars": "error",
+    'eslint/no-unassigned-vars': 'error',
 
     // Disallow unmodified loop conditions
     // https://eslint.org/docs/rules/no-unmodified-loop-condition
-    "eslint/no-unmodified-loop-condition": "error",
+    'eslint/no-unmodified-loop-condition': 'error',
 
     // Disallow control flow statements in finally blocks
     // https://eslint.org/docs/rules/no-unsafe-finally
-    "eslint/no-unsafe-finally": "error",
+    'eslint/no-unsafe-finally': 'error',
 
     // Disallow negating the left operand of relational operators
     // https://eslint.org/docs/rules/no-unsafe-negation
-    "eslint/no-unsafe-negation": "error",
+    'eslint/no-unsafe-negation': 'error',
 
     // Disallow use of optional chaining in contexts where the undefined value is not allowed
     // https://eslint.org/docs/rules/no-unsafe-optional-chaining
-    "eslint/no-unsafe-optional-chaining": ["error", { "disallowArithmeticOperators": true }],
+    'eslint/no-unsafe-optional-chaining': ['error', { disallowArithmeticOperators: true }],
 
     // Disallow unused private class members
     // https://eslint.org/docs/rules/no-unused-private-class-members
-    "eslint/no-unused-private-class-members": "error",
+    'eslint/no-unused-private-class-members': 'error',
 
     // Disallow unused variables
     // https://eslint.org/docs/rules/no-unused-vars
-    "eslint/no-unused-vars": [
-      "error",
+    'eslint/no-unused-vars': [
+      'error',
       {
-        "vars": "all",
-        "args": "after-used",
-        "argsIgnorePattern": "^_",
-        "caughtErrors": "all",
-        "caughtErrorsIgnorePattern": "^_",
-        "destructuredArrayIgnorePattern": "^_",
-        "ignoreRestSiblings": true,
-        "varsIgnorePattern": "^_",
+        vars: 'all',
+        args: 'after-used',
+        argsIgnorePattern: '^_',
+        caughtErrors: 'all',
+        caughtErrorsIgnorePattern: '^_',
+        destructuredArrayIgnorePattern: '^_',
+        ignoreRestSiblings: true,
+        varsIgnorePattern: '^_',
       },
     ],
 
     // Disallow the use of variables before they are defined
     // https://eslint.org/docs/rules/no-use-before-define
-    "eslint/no-use-before-define": [
-      "error",
-      { "functions": true, "classes": true, "variables": true },
-    ],
+    'eslint/no-use-before-define': ['error', { functions: true, classes: true, variables: true }],
 
     // Disallow useless backreferences in regular expressions
     // https://eslint.org/docs/rules/no-useless-backreference
-    "eslint/no-useless-backreference": "error",
+    'eslint/no-useless-backreference': 'error',
 
     // Require calls to isNaN() when checking for NaN
     // https://eslint.org/docs/rules/use-isnan
-    "eslint/use-isnan": "error",
+    'eslint/use-isnan': 'error',
 
     // Enforce comparing typeof expressions against valid strings
     // https://eslint.org/docs/rules/valid-typeof
-    "eslint/valid-typeof": ["error", { "requireStringLiterals": true }],
+    'eslint/valid-typeof': ['error', { requireStringLiterals: true }],
 
     // -- Suggestions --
 
     // Enforce getter and setter pairs in objects and classes
     // https://eslint.org/docs/rules/accessor-pairs
-    "eslint/accessor-pairs": "error",
+    'eslint/accessor-pairs': 'error',
 
     // Enforce the use of variables within the scope they are defined
     // https://eslint.org/docs/rules/block-scoped-var
-    "eslint/block-scoped-var": "error",
+    'eslint/block-scoped-var': 'error',
 
     // Enforce default clauses in switch statements to be last
     // https://eslint.org/docs/rules/default-case-last
-    "eslint/default-case-last": "error",
+    'eslint/default-case-last': 'error',
 
     // Enforce default parameters to be last
     // https://eslint.org/docs/rules/default-param-last
-    "eslint/default-param-last": "error",
+    'eslint/default-param-last': 'error',
 
     // Require the use of === and !==
     // https://eslint.org/docs/rules/eqeqeq
-    "eslint/eqeqeq": ["error", "always", { "null": "ignore" }],
+    'eslint/eqeqeq': ['error', 'always', { null: 'ignore' }],
 
     // Require for-in loops to include an if statement
     // https://eslint.org/docs/rules/guard-for-in
-    "eslint/guard-for-in": "error",
+    'eslint/guard-for-in': 'error',
 
     // Enforce minimum and maximum identifier lengths
     // https://eslint.org/docs/rules/id-length
-    "eslint/id-length": [
-      "error",
+    'eslint/id-length': [
+      'error',
       {
-        "min": 2,
-        "exceptions": ["_", "i", "j", "x", "y"],
+        min: 2,
+        exceptions: ['_', 'i', 'j', 'x', 'y'],
       },
     ],
 
     // Enforce a maximum number of classes per file
     // https://eslint.org/docs/rules/max-classes-per-file
-    "eslint/max-classes-per-file": ["error", 1],
+    'eslint/max-classes-per-file': ['error', 1],
 
     // Disallow the use of alert, confirm, and prompt
     // https://eslint.org/docs/rules/no-alert
-    "eslint/no-alert": "error",
+    'eslint/no-alert': 'error',
 
     // Disallow Array constructors
     // https://eslint.org/docs/rules/no-array-constructor
-    "eslint/no-array-constructor": "error",
+    'eslint/no-array-constructor': 'error',
 
     // Disallow bitwise operators
     // https://eslint.org/docs/rules/no-bitwise
-    "eslint/no-bitwise": "error",
+    'eslint/no-bitwise': 'error',
 
     // Disallow the use of arguments.caller or arguments.callee
     // https://eslint.org/docs/rules/no-caller
-    "eslint/no-caller": "error",
+    'eslint/no-caller': 'error',
 
     // Disallow lexical declarations in case clauses
     // https://eslint.org/docs/rules/no-case-declarations
-    "eslint/no-case-declarations": "error",
+    'eslint/no-case-declarations': 'error',
 
     // Disallow the use of console
     // https://eslint.org/docs/rules/no-console
-    "eslint/no-console": "error",
+    'eslint/no-console': 'error',
 
     // Disallow continue statements
     // https://eslint.org/docs/rules/no-continue
-    "eslint/no-continue": "error",
+    'eslint/no-continue': 'error',
 
     // Disallow deleting variables
     // https://eslint.org/docs/rules/no-delete-var
-    "eslint/no-delete-var": "error",
+    'eslint/no-delete-var': 'error',
 
     // Disallow else blocks after return statements in if statements
     // https://eslint.org/docs/rules/no-else-return
-    "eslint/no-else-return": ["error", { "allowElseIf": false }],
+    'eslint/no-else-return': ['error', { allowElseIf: false }],
 
     // Disallow empty block statements
     // https://eslint.org/docs/rules/no-empty
-    "eslint/no-empty": "error",
+    'eslint/no-empty': 'error',
 
     // Disallow empty functions
     // https://eslint.org/docs/rules/no-empty-function
-    "eslint/no-empty-function": ["error", { "allow": ["arrowFunctions", "functions", "methods"] }],
+    'eslint/no-empty-function': ['error', { allow: ['arrowFunctions', 'functions', 'methods'] }],
 
     // Disallow empty static blocks
     // https://eslint.org/docs/rules/no-empty-static-block
-    "eslint/no-empty-static-block": "error",
+    'eslint/no-empty-static-block': 'error',
 
     // Disallow the use of eval()
     // https://eslint.org/docs/rules/no-eval
-    "eslint/no-eval": "error",
+    'eslint/no-eval': 'error',
 
     // Disallow extending native types
     // https://eslint.org/docs/rules/no-extend-native
-    "eslint/no-extend-native": "error",
+    'eslint/no-extend-native': 'error',
 
     // Disallow unnecessary calls to .bind()
     // https://eslint.org/docs/rules/no-extra-bind
-    "eslint/no-extra-bind": "error",
+    'eslint/no-extra-bind': 'error',
 
     // Disallow unnecessary boolean casts
     // https://eslint.org/docs/rules/no-extra-boolean-cast
-    "eslint/no-extra-boolean-cast": "error",
+    'eslint/no-extra-boolean-cast': 'error',
 
     // Disallow unnecessary labels
     // https://eslint.org/docs/rules/no-extra-label
-    "eslint/no-extra-label": "error",
+    'eslint/no-extra-label': 'error',
 
     // Disallow assignments to native objects or read-only global variables
     // https://eslint.org/docs/rules/no-global-assign
-    "eslint/no-global-assign": "error",
+    'eslint/no-global-assign': 'error',
 
     // Disallow shorthand type conversions
     // https://eslint.org/docs/rules/no-implicit-coercion
-    "eslint/no-implicit-coercion": "error",
+    'eslint/no-implicit-coercion': 'error',
 
     // Disallow the use of the __iterator__ property
     // https://eslint.org/docs/rules/no-iterator
-    "eslint/no-iterator": "error",
+    'eslint/no-iterator': 'error',
 
     // Disallow labels that share a name with a variable
     // https://eslint.org/docs/rules/no-label-var
-    "eslint/no-label-var": "error",
+    'eslint/no-label-var': 'error',
 
     // Disallow labeled statements
     // https://eslint.org/docs/rules/no-labels
-    "eslint/no-labels": "error",
+    'eslint/no-labels': 'error',
 
     // Disallow unnecessary nested blocks
     // https://eslint.org/docs/rules/no-lone-blocks
-    "eslint/no-lone-blocks": "error",
+    'eslint/no-lone-blocks': 'error',
 
     // Disallow if statements as the only statement in else blocks
     // https://eslint.org/docs/rules/no-lonely-if
-    "eslint/no-lonely-if": "error",
+    'eslint/no-lonely-if': 'error',
 
     // Disallow function declarations that contain unsafe references inside loop statements
     // https://eslint.org/docs/rules/no-loop-func
-    "eslint/no-loop-func": "error",
+    'eslint/no-loop-func': 'error',
 
     // Disallow use of chained assignment expressions
     // https://eslint.org/docs/rules/no-multi-assign
-    "eslint/no-multi-assign": "error",
+    'eslint/no-multi-assign': 'error',
 
     // Disallow multiline strings
     // https://eslint.org/docs/rules/no-multi-str
-    "eslint/no-multi-str": "error",
+    'eslint/no-multi-str': 'error',
 
     // Disallow nested ternary expressions
     // https://eslint.org/docs/rules/no-nested-ternary
-    "eslint/no-nested-ternary": "error",
+    'eslint/no-nested-ternary': 'error',
 
     // Disallow new operators outside of assignments or comparisons
     // https://eslint.org/docs/rules/no-new
-    "eslint/no-new": "error",
+    'eslint/no-new': 'error',
 
     // Disallow new operators with the Function object
     // https://eslint.org/docs/rules/no-new-func
-    "eslint/no-new-func": "error",
+    'eslint/no-new-func': 'error',
 
     // Disallow new operators with the String, Number, and Boolean objects
     // https://eslint.org/docs/rules/no-new-wrappers
-    "eslint/no-new-wrappers": "error",
+    'eslint/no-new-wrappers': 'error',
 
     // Disallow \8 and \9 escape sequences in string literals
     // https://eslint.org/docs/rules/no-nonoctal-decimal-escape
-    "eslint/no-nonoctal-decimal-escape": "error",
+    'eslint/no-nonoctal-decimal-escape': 'error',
 
     // Disallow calls to the Object constructor without an argument
     // https://eslint.org/docs/rules/no-object-constructor
-    "eslint/no-object-constructor": "error",
+    'eslint/no-object-constructor': 'error',
 
     // Disallow reassigning function parameters
     // https://eslint.org/docs/rules/no-param-reassign
-    "eslint/no-param-reassign": [
-      "error",
+    'eslint/no-param-reassign': [
+      'error',
       {
-        "props": true,
-        "ignorePropertyModificationsFor": [
-          "acc",
-          "accumulator",
-          "e",
-          "ctx",
-          "context",
-          "req",
-          "request",
-          "res",
-          "response",
-          "$scope",
-          "staticContext",
+        props: true,
+        ignorePropertyModificationsFor: [
+          'acc',
+          'accumulator',
+          'e',
+          'ctx',
+          'context',
+          'req',
+          'request',
+          'res',
+          'response',
+          '$scope',
+          'staticContext',
         ],
       },
     ],
 
     // Disallow the unary operators ++ and --
     // https://eslint.org/docs/rules/no-plusplus
-    "eslint/no-plusplus": ["error", { "allowForLoopAfterthoughts": true }],
+    'eslint/no-plusplus': ['error', { allowForLoopAfterthoughts: true }],
 
     // Disallow the use of the __proto__ property
     // https://eslint.org/docs/rules/no-proto
-    "eslint/no-proto": "error",
+    'eslint/no-proto': 'error',
 
     // Disallow variable redeclaration
     // https://eslint.org/docs/rules/no-redeclare
-    "eslint/no-redeclare": "error",
+    'eslint/no-redeclare': 'error',
 
     // Disallow multiple spaces in regular expressions
     // https://eslint.org/docs/rules/no-regex-spaces
-    "eslint/no-regex-spaces": "error",
+    'eslint/no-regex-spaces': 'error',
 
     // Disallow assignment operators in return statements
     // https://eslint.org/docs/rules/no-return-assign
-    "eslint/no-return-assign": ["error", "always"],
+    'eslint/no-return-assign': ['error', 'always'],
 
     // Disallow use of javascript: urls
     // https://eslint.org/docs/rules/no-script-url
-    "eslint/no-script-url": "error",
+    'eslint/no-script-url': 'error',
 
     // Disallow comma operators
     // https://eslint.org/docs/rules/no-sequences
-    "eslint/no-sequences": "error",
+    'eslint/no-sequences': 'error',
 
     // Disallow variable declarations from shadowing variables declared in the outer scope
     // https://eslint.org/docs/rules/no-shadow
-    "eslint/no-shadow": "error",
+    'eslint/no-shadow': 'error',
 
     // Disallow identifiers from shadowing restricted names
     // https://eslint.org/docs/rules/no-shadow-restricted-names
-    "eslint/no-shadow-restricted-names": "error",
+    'eslint/no-shadow-restricted-names': 'error',
 
     // Disallow throwing literals as exceptions
     // https://eslint.org/docs/rules/no-throw-literal
-    "eslint/no-throw-literal": "error",
+    'eslint/no-throw-literal': 'error',
 
     // Disallow ternary operators when simpler alternatives exist
     // https://eslint.org/docs/rules/no-unneeded-ternary
-    "eslint/no-unneeded-ternary": ["error", { "defaultAssignment": false }],
+    'eslint/no-unneeded-ternary': ['error', { defaultAssignment: false }],
 
     // Disallow unused expressions
     // https://eslint.org/docs/rules/no-unused-expressions
-    "eslint/no-unused-expressions": "error",
+    'eslint/no-unused-expressions': 'error',
 
     // Disallow unused labels
     // https://eslint.org/docs/rules/no-unused-labels
-    "eslint/no-unused-labels": "error",
+    'eslint/no-unused-labels': 'error',
 
     // Disallow unnecessary catch clauses
     // https://eslint.org/docs/rules/no-useless-catch
-    "eslint/no-useless-catch": "error",
+    'eslint/no-useless-catch': 'error',
 
     // Disallow unnecessary computed property keys in objects and classes
     // https://eslint.org/docs/rules/no-useless-computed-key
-    "eslint/no-useless-computed-key": "error",
+    'eslint/no-useless-computed-key': 'error',
 
     // Disallow unnecessary concatenation of literals or template literals
     // https://eslint.org/docs/rules/no-useless-concat
-    "eslint/no-useless-concat": "error",
+    'eslint/no-useless-concat': 'error',
 
     // Disallow unnecessary constructors
     // https://eslint.org/docs/rules/no-useless-constructor
-    "eslint/no-useless-constructor": "error",
+    'eslint/no-useless-constructor': 'error',
 
     // Disallow unnecessary escape characters
     // https://eslint.org/docs/rules/no-useless-escape
-    "eslint/no-useless-escape": "error",
+    'eslint/no-useless-escape': 'error',
 
     // Disallow renaming import, export, and destructured assignments to the same name
     // https://eslint.org/docs/rules/no-useless-rename
-    "eslint/no-useless-rename": "error",
+    'eslint/no-useless-rename': 'error',
 
     // Disallow redundant return statements
     // https://eslint.org/docs/rules/no-useless-return
-    "eslint/no-useless-return": "error",
+    'eslint/no-useless-return': 'error',
 
     // Require let or const instead of var
     // https://eslint.org/docs/rules/no-var
-    "eslint/no-var": "error",
+    'eslint/no-var': 'error',
 
     // Disallow void operators
     // https://eslint.org/docs/rules/no-void
-    "eslint/no-void": "error",
-    // note: typescript.jsonc overrides this to ["error", { "allowAsStatement": true }]
+    'eslint/no-void': 'error',
+    // note: typescript.ts overrides this to ["error", { "allowAsStatement": true }]
 
     // Disallow with statements
     // https://eslint.org/docs/rules/no-with
-    "eslint/no-with": "error",
+    'eslint/no-with': 'error',
 
     // Require const declarations for variables that are never reassigned after declared
     // https://eslint.org/docs/rules/prefer-const
-    "eslint/prefer-const": ["error", { "destructuring": "any", "ignoreReadBeforeAssign": true }],
+    'eslint/prefer-const': ['error', { destructuring: 'any', ignoreReadBeforeAssign: true }],
 
     // Require destructuring from arrays and/or objects
     // https://eslint.org/docs/rules/prefer-destructuring
-    "eslint/prefer-destructuring": [
-      "error",
+    'eslint/prefer-destructuring': [
+      'error',
       {
-        "VariableDeclarator": { "array": false, "object": true },
-        "AssignmentExpression": { "array": true, "object": false },
+        VariableDeclarator: { array: false, object: true },
+        AssignmentExpression: { array: true, object: false },
       },
-      { "enforceForRenamedProperties": false },
+      { enforceForRenamedProperties: false },
     ],
 
     // Disallow the use of Math.pow in favor of the ** operator
     // https://eslint.org/docs/rules/prefer-exponentiation-operator
-    "eslint/prefer-exponentiation-operator": "error",
+    'eslint/prefer-exponentiation-operator': 'error',
 
     // Disallow parseInt() and Number.parseInt() in favor of binary, octal, and hexadecimal literals
     // https://eslint.org/docs/rules/prefer-numeric-literals
-    "eslint/prefer-numeric-literals": "error",
+    'eslint/prefer-numeric-literals': 'error',
 
     // Disallow use of Object.prototype.hasOwnProperty.call() and prefer use of Object.hasOwn()
     // https://eslint.org/docs/rules/prefer-object-has-own
-    "eslint/prefer-object-has-own": "error",
+    'eslint/prefer-object-has-own': 'error',
 
     // Prefer use of an object spread over Object.assign
     // https://eslint.org/docs/rules/prefer-object-spread
-    "eslint/prefer-object-spread": "error",
+    'eslint/prefer-object-spread': 'error',
 
     // Require using Error objects as Promise rejection reasons
     // https://eslint.org/docs/rules/prefer-promise-reject-errors
-    "eslint/prefer-promise-reject-errors": ["error", { "allowEmptyReject": true }],
+    'eslint/prefer-promise-reject-errors': ['error', { allowEmptyReject: true }],
 
     // Require rest parameters instead of arguments
     // https://eslint.org/docs/rules/prefer-rest-params
-    "eslint/prefer-rest-params": "error",
+    'eslint/prefer-rest-params': 'error',
 
     // Require spread operators instead of .apply()
     // https://eslint.org/docs/rules/prefer-spread
-    "eslint/prefer-spread": "error",
+    'eslint/prefer-spread': 'error',
 
     // Require template literals instead of string concatenation
     // https://eslint.org/docs/rules/prefer-template
-    "eslint/prefer-template": "error",
+    'eslint/prefer-template': 'error',
 
     // Disallow losing originally caught error when re-throwing custom errors
     // https://eslint.org/docs/rules/preserve-caught-error
-    "eslint/preserve-caught-error": ["error", { "requireCatchParameter": false }],
+    'eslint/preserve-caught-error': ['error', { requireCatchParameter: false }],
 
     // Enforce the consistent use of the radix argument when using parseInt()
     // https://eslint.org/docs/rules/radix
-    "eslint/radix": "error",
+    'eslint/radix': 'error',
 
     // Disallow async functions which have no await expression
     // https://eslint.org/docs/rules/require-await
-    "eslint/require-await": "error",
+    'eslint/require-await': 'error',
 
     // Require generator functions to contain yield
     // https://eslint.org/docs/rules/require-yield
-    "eslint/require-yield": "error",
+    'eslint/require-yield': 'error',
 
     // Require symbol descriptions
     // https://eslint.org/docs/rules/symbol-description
-    "eslint/symbol-description": "error",
+    'eslint/symbol-description': 'error',
 
     // Require or disallow "Yoda" conditions
     // https://eslint.org/docs/rules/yoda
-    "eslint/yoda": "error",
+    'eslint/yoda': 'error',
 
     // -- oxc rules (oxlint-specific, no eslint equivalent) --
     // These are bug-catchers that oxlint can detect natively.
 
     // Disallow calling array methods on arguments (it's array-like, not an array)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/bad-array-method-on-arguments.html
-    "oxc/bad-array-method-on-arguments": "error",
+    'oxc/bad-array-method-on-arguments': 'error',
 
     // Disallow comparing charAt() result to multi-char string (always false)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/bad-char-at-comparison.html
-    "oxc/bad-char-at-comparison": "error",
+    'oxc/bad-char-at-comparison': 'error',
 
     // Disallow chained comparisons like a < b < c (evaluates left to boolean first)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/bad-comparison-sequence.html
-    "oxc/bad-comparison-sequence": "error",
+    'oxc/bad-comparison-sequence': 'error',
 
     // Disallow swapped/nested min/max that produce constant results
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/bad-min-max-func.html
-    "oxc/bad-min-max-func": "error",
+    'oxc/bad-min-max-func': 'error',
 
     // Disallow reference-equality checks against object/array literals (always false)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/bad-object-literal-comparison.html
-    "oxc/bad-object-literal-comparison": "error",
+    'oxc/bad-object-literal-comparison': 'error',
 
     // Disallow replaceAll with regex missing the global flag (throws at runtime)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/bad-replace-all-arg.html
-    "oxc/bad-replace-all-arg": "error",
+    'oxc/bad-replace-all-arg': 'error',
 
     // Disallow redundant or impossible comparisons (x >= 5 && x >= 3)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/const-comparisons.html
-    "oxc/const-comparisons": "error",
+    'oxc/const-comparisons': 'error',
 
     // Disallow comparisons that can be simplified (a === b || a < b → a <= b)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/double-comparisons.html
-    "oxc/double-comparisons": "error",
+    'oxc/double-comparisons': 'error',
 
     // Disallow operations that always produce the same value (x * 0, x & 0)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/erasing-op.html
-    "oxc/erasing-op": "error",
+    'oxc/erasing-op': 'error',
 
     // Disallow constructing Error without throw
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/missing-throw.html
-    "oxc/missing-throw": "error",
+    'oxc/missing-throw': 'error',
 
     // Disallow numeric arguments outside valid range (parseInt radix, toFixed digits)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/number-arg-out-of-range.html
-    "oxc/number-arg-out-of-range": "error",
+    'oxc/number-arg-out-of-range': 'error',
 
     // Disallow function params only used in recursive self-calls (likely a bug)
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/only-used-in-recursion.html
-    "oxc/only-used-in-recursion": "error",
+    'oxc/only-used-in-recursion': 'error',
 
     // Disallow passing functions to array methods when signatures don't match
     // https://oxc.rs/docs/guide/usage/linter/rules/oxc/uninvoked-array-callback.html
-    "oxc/uninvoked-array-callback": "error",
+    'oxc/uninvoked-array-callback': 'error',
   },
-}
+} satisfies RuleFile;