@wistia/oxlint-config 0.0.1 → 0.2.0

package/rules/typescript.jsonc

@@ -0,0 +1,457 @@
+{
+  "$schema": "../node_modules/oxlint/configuration_schema.json",
+  "plugins": ["typescript"],
+  "categories": {},
+  "rules": {
+    // -- Disable base eslint rules superseded by typescript equivalents --
+    "eslint/class-methods-use-this": "off",
+    "eslint/default-param-last": "off",
+    "eslint/init-declarations": "off",
+    "eslint/max-params": "off",
+    "eslint/no-array-constructor": "off",
+    "eslint/no-dupe-class-members": "off",
+    "eslint/no-empty-function": "off",
+    "eslint/no-loop-func": "off",
+    "eslint/no-magic-numbers": "off",
+    "eslint/no-redeclare": "off",
+    "eslint/no-restricted-imports": "off",
+    "eslint/no-shadow": "off",
+    "eslint/no-throw-literal": "off",
+    "eslint/no-unused-expressions": "off",
+    "eslint/no-unused-private-class-members": "off",
+    "eslint/no-unused-vars": "off",
+    "eslint/no-use-before-define": "off",
+    "eslint/no-useless-constructor": "off",
+    "eslint/prefer-destructuring": "off",
+    "eslint/require-await": "off",
+
+    // recommended to be disabled for TypeScript projects
+    // https://github.com/typescript-eslint/typescript-eslint/blob/main/docs/linting/TROUBLESHOOTING.md#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors
+    "eslint/no-undef": "off",
+
+    // Override base no-void to allow void as a statement (common in TS for fire-and-forget promises)
+    "eslint/no-void": ["error", { "allowAsStatement": true }],
+
+    // Override base id-length to disable checking generic type parameters.
+    // ESLint's id-length never sees TS type params (they're not in the ESLint AST),
+    // but oxlint has native TS support so it checks them. Setting checkGeneric to
+    // false restores parity with ESLint's behavior.
+    // https://oxc.rs/docs/guide/usage/linter/rules/eslint/id-length.html
+    "eslint/id-length": [
+      "error",
+      {
+        "min": 2,
+        "exceptions": ["_", "i", "j", "x", "y"],
+        "checkGeneric": false,
+      },
+    ],
+
+    // -- TypeScript rules --
+
+    // Require that function overload signatures be consecutive
+    // https://typescript-eslint.io/rules/adjacent-overload-signatures
+    "typescript/adjacent-overload-signatures": "error",
+
+    // Require consistently using either T[] or Array<T> for arrays
+    // https://typescript-eslint.io/rules/array-type
+    "typescript/array-type": "error",
+
+    // Disallow awaiting a value that is not a Thenable
+    // https://typescript-eslint.io/rules/await-thenable
+    "typescript/await-thenable": "error",
+
+    // Disallow @ts-<directive> comments or require descriptions after directives
+    // https://typescript-eslint.io/rules/ban-ts-comment
+    "typescript/ban-ts-comment": "error",
+
+    // Disallow // tslint:<rule-flag> comments
+    // https://typescript-eslint.io/rules/ban-tslint-comment
+    "typescript/ban-tslint-comment": "error",
+
+    // Enforce that literals on classes are exposed in a consistent style
+    // https://typescript-eslint.io/rules/class-literal-property-style
+    "typescript/class-literal-property-style": "error",
+
+    // Enforce specifying generic type arguments on type annotation or constructor name of a constructor call
+    // https://typescript-eslint.io/rules/consistent-generic-constructors
+    "typescript/consistent-generic-constructors": "error",
+
+    // Require or disallow the Record type
+    // https://typescript-eslint.io/rules/consistent-indexed-object-style
+    "typescript/consistent-indexed-object-style": "error",
+
+    // Enforce consistent usage of type assertions
+    // https://typescript-eslint.io/rules/consistent-type-assertions
+    "typescript/consistent-type-assertions": "error",
+
+    // Enforce type definitions to consistently use either interface or type
+    // https://typescript-eslint.io/rules/consistent-type-definitions
+    // decision: prefer type to interface for consistency
+    "typescript/consistent-type-definitions": ["error", "type"],
+
+    // Enforce consistent usage of type exports
+    // https://typescript-eslint.io/rules/consistent-type-exports
+    "typescript/consistent-type-exports": "error",
+
+    // Enforce consistent usage of type imports
+    // https://typescript-eslint.io/rules/consistent-type-imports
+    "typescript/consistent-type-imports": [
+      "error",
+      {
+        "prefer": "type-imports",
+        "disallowTypeAnnotations": false,
+        "fixStyle": "separate-type-imports",
+      },
+    ],
+
+    // Enforce dot notation whenever possible
+    // https://typescript-eslint.io/rules/dot-notation
+    "typescript/dot-notation": "error",
+
+    // Require explicit accessibility modifiers on class properties and methods
+    // https://typescript-eslint.io/rules/explicit-module-boundary-types
+    "typescript/explicit-module-boundary-types": "error",
+
+    // Disallow using the delete operator on array values
+    // https://typescript-eslint.io/rules/no-array-delete
+    "typescript/no-array-delete": "error",
+
+    // Require .toString() to only be called on objects which provide useful information
+    // https://typescript-eslint.io/rules/no-base-to-string
+    "typescript/no-base-to-string": "error",
+
+    // Disallow non-null assertion in locations that may be confusing
+    // https://typescript-eslint.io/rules/no-confusing-non-null-assertion
+    "typescript/no-confusing-non-null-assertion": "error",
+
+    // Require expressions of type void to appear in statement position
+    // https://typescript-eslint.io/rules/no-confusing-void-expression
+    "typescript/no-confusing-void-expression": ["error", { "ignoreArrowShorthand": true }],
+
+    // Disallow using code marked as @deprecated
+    // https://typescript-eslint.io/rules/no-deprecated
+    "typescript/no-deprecated": "error",
+
+    // Disallow duplicate enum member values
+    // https://typescript-eslint.io/rules/no-duplicate-enum-values
+    "typescript/no-duplicate-enum-values": "error",
+
+    // Disallow duplicate constituents of union or intersection types
+    // https://typescript-eslint.io/rules/no-duplicate-type-constituents
+    "typescript/no-duplicate-type-constituents": "error",
+
+    // Disallow using the delete operator on computed key expressions
+    // https://typescript-eslint.io/rules/no-dynamic-delete
+    "typescript/no-dynamic-delete": "error",
+
+    // Disallow accidentally using the "empty object" type
+    // https://typescript-eslint.io/rules/no-empty-object-type
+    "typescript/no-empty-object-type": "error",
+
+    // Disallow the any type
+    // https://typescript-eslint.io/rules/no-explicit-any
+    "typescript/no-explicit-any": "error",
+
+    // Disallow extra non-null assertions
+    // https://typescript-eslint.io/rules/no-extra-non-null-assertion
+    "typescript/no-extra-non-null-assertion": "error",
+
+    // Disallow classes used as namespaces
+    // https://typescript-eslint.io/rules/no-extraneous-class
+    "typescript/no-extraneous-class": "error",
+
+    // Require Promise-like statements to be handled appropriately
+    // https://typescript-eslint.io/rules/no-floating-promises
+    "typescript/no-floating-promises": "error",
+
+    // Disallow iterating over an array with a for-in loop
+    // https://typescript-eslint.io/rules/no-for-in-array
+    "typescript/no-for-in-array": "error",
+
+    // Disallow the use of eval()-like methods
+    // https://typescript-eslint.io/rules/no-implied-eval
+    "typescript/no-implied-eval": "error",
+
+    // Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers
+    // https://typescript-eslint.io/rules/no-import-type-side-effects
+    "typescript/no-import-type-side-effects": "error",
+
+    // Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean
+    // https://typescript-eslint.io/rules/no-inferrable-types
+    "typescript/no-inferrable-types": "error",
+
+    // Disallow void type outside of generic or return types
+    // https://typescript-eslint.io/rules/no-invalid-void-type
+    "typescript/no-invalid-void-type": "error",
+
+    // Disallow the void operator except when used to discard a value
+    // https://typescript-eslint.io/rules/no-meaningless-void-operator
+    "typescript/no-meaningless-void-operator": "error",
+
+    // Enforce valid definition of new and constructor
+    // https://typescript-eslint.io/rules/no-misused-new
+    "typescript/no-misused-new": "error",
+
+    // Disallow Promises in places not designed to handle them
+    // https://typescript-eslint.io/rules/no-misused-promises
+    "typescript/no-misused-promises": "error",
+
+    // Disallow using the spread operator when it might cause unexpected behavior
+    // https://typescript-eslint.io/rules/no-misused-spread
+    "typescript/no-misused-spread": "error",
+
+    // Disallow enums from having both number and string members
+    // https://typescript-eslint.io/rules/no-mixed-enums
+    "typescript/no-mixed-enums": "error",
+
+    // Disallow TypeScript namespaces
+    // https://typescript-eslint.io/rules/no-namespace
+    "typescript/no-namespace": "error",
+
+    // Disallow non-null assertions in the left operand of a nullish coalescing operator
+    // https://typescript-eslint.io/rules/no-non-null-asserted-nullish-coalescing
+    "typescript/no-non-null-asserted-nullish-coalescing": "error",
+
+    // Disallow non-null assertions after an optional chain expression
+    // https://typescript-eslint.io/rules/no-non-null-asserted-optional-chain
+    "typescript/no-non-null-asserted-optional-chain": "error",
+
+    // Disallow non-null assertions using the ! postfix operator
+    // https://typescript-eslint.io/rules/no-non-null-assertion
+    "typescript/no-non-null-assertion": "error",
+
+    // Disallow members of unions and intersections that do nothing or override type information
+    // https://typescript-eslint.io/rules/no-redundant-type-constituents
+    "typescript/no-redundant-type-constituents": "error",
+
+    // Disallow invocation of require()
+    // https://typescript-eslint.io/rules/no-require-imports
+    "typescript/no-require-imports": "error",
+
+    // Disallow certain types
+    // https://typescript-eslint.io/rules/no-restricted-types
+    "typescript/no-restricted-types": "error",
+
+    // Disallow aliasing this
+    // https://typescript-eslint.io/rules/no-this-alias
+    "typescript/no-this-alias": "error",
+
+    // Disallow unnecessary equality comparisons against boolean literals
+    // https://typescript-eslint.io/rules/no-unnecessary-boolean-literal-compare
+    "typescript/no-unnecessary-boolean-literal-compare": "error",
+
+    // Disallow conditionals where the type is always truthy or always falsy
+    // https://typescript-eslint.io/rules/no-unnecessary-condition
+    "typescript/no-unnecessary-condition": "error",
+
+    // Disallow unnecessary assignment of constructor property parameter
+    // https://typescript-eslint.io/rules/no-unnecessary-parameter-property-assignment
+    "typescript/no-unnecessary-parameter-property-assignment": "error",
+
+    // Disallow unnecessary namespace qualifiers
+    // https://typescript-eslint.io/rules/no-unnecessary-qualifier
+    "typescript/no-unnecessary-qualifier": "error",
+
+    // Disallow unnecessary template expressions
+    // https://typescript-eslint.io/rules/no-unnecessary-template-expression
+    "typescript/no-unnecessary-template-expression": "error",
+
+    // Disallow type arguments that are equal to the default
+    // https://typescript-eslint.io/rules/no-unnecessary-type-arguments
+    "typescript/no-unnecessary-type-arguments": "error",
+
+    // Disallow type assertions that do not change the type of an expression
+    // https://typescript-eslint.io/rules/no-unnecessary-type-assertion
+    "typescript/no-unnecessary-type-assertion": "error",
+
+    // Disallow unnecessary constraints on generic types
+    // https://typescript-eslint.io/rules/no-unnecessary-type-constraint
+    "typescript/no-unnecessary-type-constraint": "error",
+
+    // Disallow conversion idioms when they do not change the type or value of the expression
+    // https://typescript-eslint.io/rules/no-unnecessary-type-conversion
+    "typescript/no-unnecessary-type-conversion": "error",
+
+    // Disallow type parameters that only appear once
+    // https://typescript-eslint.io/rules/no-unnecessary-type-parameters
+    "typescript/no-unnecessary-type-parameters": "error",
+
+    // Disallow calling a function with a value with type any
+    // https://typescript-eslint.io/rules/no-unsafe-argument
+    "typescript/no-unsafe-argument": "error",
+
+    // Disallow assigning a value with type any to variables and properties
+    // https://typescript-eslint.io/rules/no-unsafe-assignment
+    "typescript/no-unsafe-assignment": "error",
+
+    // Disallow calling a value with type any
+    // https://typescript-eslint.io/rules/no-unsafe-call
+    "typescript/no-unsafe-call": "error",
+
+    // Disallow unsafe declaration merging
+    // https://typescript-eslint.io/rules/no-unsafe-declaration-merging
+    "typescript/no-unsafe-declaration-merging": "error",
+
+    // Disallow comparing an enum value with a non-enum value
+    // https://typescript-eslint.io/rules/no-unsafe-enum-comparison
+    "typescript/no-unsafe-enum-comparison": "error",
+
+    // Disallow using the unsafe built-in Function type
+    // https://typescript-eslint.io/rules/no-unsafe-function-type
+    "typescript/no-unsafe-function-type": "error",
+
+    // Disallow member access on a value with type any
+    // https://typescript-eslint.io/rules/no-unsafe-member-access
+    "typescript/no-unsafe-member-access": "error",
+
+    // Disallow returning a value with type any from a function
+    // https://typescript-eslint.io/rules/no-unsafe-return
+    "typescript/no-unsafe-return": "error",
+
+    // Disallow type assertions that narrow a type
+    // https://typescript-eslint.io/rules/no-unsafe-type-assertion
+    "typescript/no-unsafe-type-assertion": "error",
+
+    // Require unary negation to take a number
+    // https://typescript-eslint.io/rules/no-unsafe-unary-minus
+    "typescript/no-unsafe-unary-minus": "error",
+
+    // Disallow empty exports that don't change anything in a module file
+    // https://typescript-eslint.io/rules/no-useless-empty-export
+    "typescript/no-useless-empty-export": "error",
+
+    // Disallow using confusing built-in primitive class wrappers
+    // https://typescript-eslint.io/rules/no-wrapper-object-types
+    "typescript/no-wrapper-object-types": "error",
+
+    // Enforce non-null assertions over explicit type casts
+    // https://typescript-eslint.io/rules/non-nullable-type-assertion-style
+    // decision: disabled because it conflicts with `no-non-null-assertion` — this rule's autofix
+    // rewrites `value as T` to `value!`, which `no-non-null-assertion` then rejects
+    "typescript/non-nullable-type-assertion-style": "off",
+
+    // Disallow throwing non-Error values as exceptions
+    // https://typescript-eslint.io/rules/only-throw-error
+    "typescript/only-throw-error": "error",
+
+    // Require or disallow parameter properties in class constructors
+    // https://typescript-eslint.io/rules/parameter-properties
+    "typescript/parameter-properties": "error",
+
+    // Enforce the use of as const over literal type
+    // https://typescript-eslint.io/rules/prefer-as-const
+    "typescript/prefer-as-const": "error",
+
+    // Require each enum member value to be explicitly initialized
+    // https://typescript-eslint.io/rules/prefer-enum-initializers
+    "typescript/prefer-enum-initializers": "error",
+
+    // Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0]
+    // https://typescript-eslint.io/rules/prefer-find
+    "typescript/prefer-find": "error",
+
+    // Enforce the use of for-of loop over the standard for loop where possible
+    // https://typescript-eslint.io/rules/prefer-for-of
+    "typescript/prefer-for-of": "error",
+
+    // Enforce using function types instead of interfaces with call signatures
+    // https://typescript-eslint.io/rules/prefer-function-type
+    "typescript/prefer-function-type": "error",
+
+    // Enforce includes method over indexOf method
+    // https://typescript-eslint.io/rules/prefer-includes
+    "typescript/prefer-includes": "error",
+
+    // Require all enum members to be literal values
+    // https://typescript-eslint.io/rules/prefer-literal-enum-member
+    "typescript/prefer-literal-enum-member": "error",
+
+    // Require using namespace keyword over module keyword to declare custom TypeScript modules
+    // https://typescript-eslint.io/rules/prefer-namespace-keyword
+    "typescript/prefer-namespace-keyword": "error",
+
+    // Enforce using the nullish coalescing operator instead of logical assignments or chaining
+    // https://typescript-eslint.io/rules/prefer-nullish-coalescing
+    "typescript/prefer-nullish-coalescing": "error",
+
+    // Enforce using concise optional chain expressions
+    // https://typescript-eslint.io/rules/prefer-optional-chain
+    "typescript/prefer-optional-chain": "error",
+
+    // Require using Error objects as Promise rejection reasons
+    // https://typescript-eslint.io/rules/prefer-promise-reject-errors
+    "typescript/prefer-promise-reject-errors": "error",
+
+    // Require private members to be marked as readonly if they're never modified outside of the constructor
+    // https://typescript-eslint.io/rules/prefer-readonly
+    "typescript/prefer-readonly": "error",
+
+    // Enforce using type parameter when calling Array#reduce instead of casting
+    // https://typescript-eslint.io/rules/prefer-reduce-type-parameter
+    "typescript/prefer-reduce-type-parameter": "error",
+
+    // Enforce RegExp#exec over String#match if no global flag is provided
+    // https://typescript-eslint.io/rules/prefer-regexp-exec
+    "typescript/prefer-regexp-exec": "error",
+
+    // Enforce that this is used when only this type is returned
+    // https://typescript-eslint.io/rules/prefer-return-this-type
+    "typescript/prefer-return-this-type": "error",
+
+    // Enforce using String#startsWith and String#endsWith over other equivalent methods
+    // https://typescript-eslint.io/rules/prefer-string-starts-ends-with
+    "typescript/prefer-string-starts-ends-with": "error",
+
+    // Require any function or method that returns a Promise to be marked async
+    // https://typescript-eslint.io/rules/promise-function-async
+    "typescript/promise-function-async": "error",
+
+    // Enforce that get() types should be assignable to their equivalent set() type
+    // https://typescript-eslint.io/rules/related-getter-setter-pairs
+    "typescript/related-getter-setter-pairs": "error",
+
+    // Require Array#sort and Array#toSorted calls to always provide a compareFunction
+    // https://typescript-eslint.io/rules/require-array-sort-compare
+    "typescript/require-array-sort-compare": "error",
+
+    // Disallow async functions which do not return promises and have no await expression
+    // https://typescript-eslint.io/rules/require-await
+    "typescript/require-await": "error",
+
+    // Require both operands of addition to be the same type
+    // https://typescript-eslint.io/rules/restrict-plus-operands
+    "typescript/restrict-plus-operands": "error",
+
+    // Enforce template literal expressions to be of string type
+    // https://typescript-eslint.io/rules/restrict-template-expressions
+    "typescript/restrict-template-expressions": "error",
+
+    // Enforce consistent awaiting of returned promises
+    // https://typescript-eslint.io/rules/return-await
+    "typescript/return-await": "error",
+
+    // Disallow certain types in boolean expressions
+    // https://typescript-eslint.io/rules/strict-boolean-expressions
+    "typescript/strict-boolean-expressions": ["error", { "allowNullableBoolean": true }],
+
+    // Require switch-case statements to be exhaustive
+    // https://typescript-eslint.io/rules/switch-exhaustiveness-check
+    "typescript/switch-exhaustiveness-check": "error",
+
+    // Disallow certain triple slash directives in favor of ES6-style import declarations
+    // https://typescript-eslint.io/rules/triple-slash-reference
+    "typescript/triple-slash-reference": "error",
+
+    // Enforce unbound methods are called with their expected scope
+    // https://typescript-eslint.io/rules/unbound-method
+    "typescript/unbound-method": "error",
+
+    // Disallow two overloads that could be unified into one
+    // https://typescript-eslint.io/rules/unified-signatures
+    "typescript/unified-signatures": "error",
+
+    // Enforce typing arguments in .catch() callbacks as unknown
+    // https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable
+    "typescript/use-unknown-in-catch-callback-variable": "error",
+  },
+}