From 85ddbaba53d6a9a8ce10965d8f2d6ef90a673a1d Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Tue, 4 Feb 2025 05:58:43 +0900 Subject: [PATCH 01/25] docs: update Zenn articles --- articles/biome-vs-eslint-prettier-2025.md | 30 + articles/frontend-frameworks-survey.md | 752 ++++++++++++++++++ articles/frontend-frameworks/benchmark1.png | Bin 0 -> 85620 bytes articles/frontend-frameworks/benchmark2.png | Bin 0 -> 69003 bytes articles/frontend-frameworks/virtual-dom.png | Bin 0 -> 47040 bytes ...ake-full-advantage-of-typescript-eslint.md | 2 +- articles/typescript-branded-type-int.md | 136 ++-- articles/typescript-range-type.md | 229 ++++-- articles/typescript-type-level-min.md | 54 +- articles/typescript-type-utilities.md | 245 +++--- articles/typescript-void-type.md | 2 +- 11 files changed, 1142 insertions(+), 308 deletions(-) create mode 100644 articles/biome-vs-eslint-prettier-2025.md create mode 100644 articles/frontend-frameworks-survey.md create mode 100644 articles/frontend-frameworks/benchmark1.png create mode 100644 articles/frontend-frameworks/benchmark2.png create mode 100644 articles/frontend-frameworks/virtual-dom.png diff --git a/articles/biome-vs-eslint-prettier-2025.md b/articles/biome-vs-eslint-prettier-2025.md new file mode 100644 index 0000000000..e41464feeb --- /dev/null +++ b/articles/biome-vs-eslint-prettier-2025.md @@ -0,0 +1,30 @@ +--- +title: 'ESLint, prettier の代替として見たときの Biome についての感想メモ' +emoji: '🐈' +type: 'tech' # tech: 技術記事 / idea: アイデア +topics: ['biome', 'eslint', 'prettier', 'typescript'] +published: false +--- + +## Biome のメリット（ユーザー目線） + +- 速度： + - BiomeはRustで書かれており、非常に高速に動作する。 +- 統合性： + - Biome は、リンター、フォーマッター、そして将来的にコンパイラなど、複数の機能を統合している。これにより、ツール間の互換性問題を減らし、開発体験を向上させることができる。 +- 設定の簡素化： + - Biome は、デフォルト設定が優れており、多くのプロジェクトで追加設定なしに利用できる。 + - biome.json でlint ルール等に補完が効くため記述体験が良い。 +- より厳密な構文解析： + - BiomeのパーサはPrettierのパーサよりも厳密に構文を解析する。そのため、より正確にエラーを検出し、コードを整形できる +- ESLint, prettier との比較 + - 後発であるため prettier や ESLint の色々な問題を解決しており将来性がある + +prettier plugin recommended config などを超えて ESLint の rule option をがっつり定義したものと比べると（開発思想上納得できるものの）カスタマイズできる余地が少なく機能が現状まだ劣るので使いづらい。 + +## 執筆時点（2025年2月24日）時点での筆者の結論 + +ESLint + prettier の方がコードの品質を保つ事に関しては現状 Biome より高機能であるため、当分は実行が遅くても ESLint + prettier を使うことになりそうです。 +以前 [ESLint を使い倒す（おすすめルール紹介）](https://zenn.dev/noshiro_piko/articles/take-full-advantage-of-typescript-eslint) という記事で様々な ESLint ルールを紹介しましたが、これらの中には Biome にはまだ実装されていないものや設定が現状多く存在します。既に主要な ESLint plugin から移植済みの lint ルールであっても option が削られているケースも確認しており（どれだったか思い出したら書き足します🙇）、もしかしたらこれが意図的な場合一部の option は今後も追加されないかもしれません。 + +Biome の基本設定で足りないところを、重複しないように特定のルール設定だけ ON にした ESLint と prettier を併用して補う、という使い方も一応可能ではありますが、ツールの統合・設定の簡素化というメリットはむしろ確実に悪化してしまう上に速度面で得をするのかすら怪しいため、あまり得策とは言えないと思われます。 diff --git a/articles/frontend-frameworks-survey.md b/articles/frontend-frameworks-survey.md new file mode 100644 index 0000000000..7f169ac030 --- /dev/null +++ b/articles/frontend-frameworks-survey.md @@ -0,0 +1,752 @@ +--- +title: '[WIP] ウェブフロントエンドフレームワーク Survey（加筆予定）' +emoji: '🐈' +type: 'tech' # tech: 技術記事 / idea: アイデア +topics: ['javascript', 'typescript', 'react', 'frontend', 'spa'] +published: false +--- + +:::message +なるべく気を付けますが、自分はいずれのフレームワークについてもその開発者レベルで実装の詳細を熟知しているわけではありませんので、不正確になりうる点はご了承ください。誤りがあればぜひコメント欄でご指摘ください。 +::: + +## 今回取り上げたフレームワーク・ライブラリとその理由（使用時期） + +- 業務でもプライベートでも使用経験があるもの + - [React](https://react.dev/) （2019年頃～現在） + - [Angular](https://angular.dev/) (v2) （2017年～2018年頃、2020～2022年頃） +- プライベートで使用経験があるもの +- Vanilla JS, jQuery（2015年？～2017年頃） + - [Preact](https://preactjs.com/) （2021年頃～現在） + - [Solid](https://www.solidjs.com/) （2021年頃） +- 名前は元から知っていたが少ししか書いたことがないもの + - [Svelte](https://svelte.jp/) + - [Vue](https://vuejs.org/) + - [Elm](https://elm-lang.org/) + - [PureScript](https://www.purescript.org/) + - [ReScript](https://rescript-lang.org/) +- Rust (WebAssembly) を活用するタイプの SPA フレームワークも比較したいため追加 + - [DIOXUS](https://dioxuslabs.com/) + - [Yew](https://yew.rs/) + - https://github.com/flosse/rust-web-framework-comparison により詳しい比較あり +- 今回 SPA フレームワーク調査中に存在を知ったもの + - [Inferno](https://www.infernojs.org/) + - [Ember](https://emberjs.com/) + - [Lit](https://lit.dev/) + - State of JS 2024 の top 10 から + - [Qwik](https://qwik.dev/) + - [Stencil](https://stenciljs.com/) + - [HTMX](https://htmx.org/) + +## State of JS + +https://2024.stateofjs.com/ja-JP/libraries/front-end-frameworks/ + +## 比較表 + +| | 使用する言語 | View の記述言語 | レンダリング方式 | 登場時期（年） | 特徴 | +| :--------- | :--------------------- | :-------------------------- | :--------------------------------------------------- | :------------- | :------------------------------------------------------------------------------------ | +| React | JavaScript, TypeScript | JSX | 仮想DOM | 2013 | 関数コンポーネント、hooks | +| Preact | JavaScript, TypeScript | JSX | 仮想DOM | 2015 | 関数コンポーネント、hooks、軽量 | +| Inferno | JavaScript, TypeScript | JSX | 仮想DOM | 2016 | 最適化された仮想DOM実装によりハイパフォーマンス | +| Solid | JavaScript, TypeScript | JSX | fine-grainedリアクティビティ | 2019 | 仮想DOMを使わず独自のリアクティヴシステムを提供、ハイパフォーマンス・省バンドルサイズ | +| Svelte | JavaScript, TypeScript | Svelte 構文 | | 2016 | コンパイル時にコードを最適化するフレームワーク | +| Vue | JavaScript, TypeScript | JSX or テンプレート構文 | 仮想DOM | 2014 | テンプレート用の記法でデータバインディングを記述する | +| Angular | JavaScript, TypeScript | テンプレート構文 | Incremental DOM | 2009 | テンプレート用の記法でデータバインディングを記述する | +| Ember | JavaScript, TypeScript | テンプレート構文 | Glimmer | 2011 | | +| Lit | JavaScript, TypeScript | TypeScript デコレーターなど | Web Componentsの更新APIを直接利用 | 2019年頃？ | Web components を記述するための軽量ライブラリ | +| Stencil | JavaScript, TypeScript | JSX | Web Componentsの更新APIを直接利用 | 2017年 | Web Components をベースにしたコンパイラ | +| Qwik | JavaScript, TypeScript | JSX | Resumability & パーシャルハイドレーション | 2021年 | SSR との親和性を重視した設計により、高速なロードとインタラクティブ性を両立させる | +| Elm | Elm | Elm | 仮想DOM の最適化版 | 2012 | 静的型付けの純粋関数型プログラミング言語 | +| PureScript | PureScript | PureScript 独自構文 | 仮想DOM の最適化版 | 2014 | 静的型付けの純粋関数型プログラミング言語、Haskell の影響を強く受けた言語 | +| ReScript | ReScript | JSX or ReasonML | | 2020 | OCamlから派生した言語 | +| HTMX | HTMX, JavaScript | HTMX | サーバーサイドでHTMLを生成し、ブラウザで部分的な更新 | 2020年 | HTMLの拡張構文、JavaScript をほとんど書かずに動的な Web アプリケーションを開発できる | +| Yew | Rust, WebAssembly | | 仮想DOM に類似する最適化された差分検出システム | 2018年頃？ | Rust で記述 | + +## 各フレームワークの特徴 + +### [React](https://react.dev/), [Preact](https://preactjs.com/) + +```tsx +import * as React from 'react'; + +export const Counter = () => { + const [count, setCount] = React.useState(0); + + const increment = () => { + setCount((c) => c + 1); + }; + + return ( +
+

{`カウント : ${count}`}

+ +
+ ); +}; +``` + +- 仮想DOM を使用 +- 関数コンポーネントと Hooks （useState など）で記述 + - class でも記述できるが現在使われることは稀 +- 😊 hooks によりコンポーネント内 state を1行で追加したり、ロジックを関数として共通化したりといった抽象化がシンプルに行える +- 😊 すべてをJavaScript の世界で完結させることができる（Angular などでは template 構文を扱う必要がある） +- 😊 `setState` などによりディスパッチされる"rendering" でコンポーネント関数が呼び出され、その内容がメモ化されたものを除き毎回すべて再評価され、あとは仮想DOMが勝手に差分を DOM に適用してくれる、というメンタルモデルさえ獲得すればほとんど問題無く実用できる。 +- [React のルール](https://ja.react.dev/reference/rules) を守る必要がある + - これは、 コンポーネントとフックを冪等にすることやprops と state はイミュータブルに扱うことなど、自然なコンポーネント記述をしていれば抵触しないものではあります。 + - Strict Mode で検出しやすくすることもできます。 +- 🙁 React hooks のルールを守る必要がある + - Rule of React hooks + 1. 最上位でのみ Hook を呼び出す + - Hook は、ループ、条件分岐、またはネストされた関数内で呼び出してはいけません。 + - Hook は、常に React 関数のトップレベルで呼び出す必要があります。 + 2. React 関数内でのみ Hook を呼び出す + - Hook は、通常の JavaScript 関数内で呼び出してはいけません。 + - Hook は、React 関数コンポーネント、またはカスタム Hook の中で呼び出す必要があります。 + - [`react-hooks/rules-of-hooks`](https://www.npmjs.com/package/eslint-plugin-react-hooks) でほぼ検出できます。 + - これは状態管理実装の仕方に React の実装上の都合での制約が生じるものであり、他フレームワークと比べるとデメリットと呼べる可能性があるものです。 + +### [Angular](https://angular.dev/) + +```ts +import { Component } from '@angular/core'; + +@Component({ + selector: 'app-counter', + template: ` +
+

カウント: {{ count }}

+
{`${count % 2 === 0 ? '偶数' : '奇数'}`}
+ + +
+ `, + styles: [], +}) +export class CounterComponent { + count = 0; + + increment() { + this.count++; + } +} +``` + +- クラスベースコンポーネント +- style, template は別ファイルに分離することも可能 +- 🙁 覚えるべきルールが膨大 + - template 構文（ `ngIf`, `ngFor`, `ngSwitch`, ... ）を覚える必要ある。 + - コンポーネントを定義して NgModule に登録する、などの作業 +- 🙁 コード記述量が多い + - コンポーネントを一つ作成するのにも専用コマンドが用意されているほど +- 🙁 TypeScript 中のコードでありながら、 template 部分の Syntax Highlighting を行うには専用の拡張を入れる必要がある。 +- 🙁 コンポーネント作成の手間が大きい + + - template 内で参照するためのコンポーネント名 `app-counter` と JS 変数名 `CounterComponent` を別途定義する必要がある。 + - コンポーネントを定義した後 Module に別途追加しないと template 内で参照できない。 + + ```ts + import { NgModule } from '@angular/core'; + import { AppComponent } from './app.component'; + import { MyComponent } from './my-component/my-component.component'; // 追加 + + @NgModule({ + declarations: [ + AppComponent, + MyComponent, // 追加 + ], + imports: [BrowserModule], + providers: [], + bootstrap: [AppComponent], + }) + export class AppModule {} + ``` + +- レンダリングエンジン Ivy において、インクリメンタル DOM という技術を採用している。 + - 仮想DOM（Virtual DOM） との比較： + - 仮想DOM： JavaScript で DOM の構造を再現した仮想的な DOM ツリー（仮想DOM）を作成し、変更があった部分だけ実際の DOM に反映させる。 + - インクリメンタル DOM： 各コンポーネントを DOM 操作の命令列にコンパイルし、データの変更に応じて必要な部分だけを直接 DOM に変更を加える。 + - ツリーシェイカビリティとメモリ効率に優れる（らしい） + - フレームワーク間のパフォーマンス比較については後述しますが、Solid や Preact などのより優れた選択肢があるため採用の根拠にはならなさそうです。 + +### [Vue](https://vuejs.org/) + +- コンポーネント記述例（[template 構文](https://vuejs.org/guide/essentials/template-syntax.html)） + + ```vue + + + + ``` + +- コンポーネント記述例（[JSX](https://vuejs.org/guide/extras/render-function.html#jsx-tsx)） + + ```js + import { ref, reactive } from 'vue'; + + export const Counter = { + setup() { + // リアクティブなカウント変数を定義 + const count = ref(0); + + const increment = () => { + count.value++; + }; + + return () => ( +
+

カウント: {count.value}

+ +
+ ); + }, + }; + ``` + +- [Virtual DOM](https://vuejs.org/guide/extras/rendering-mechanism.html#virtual-dom) を使用 + - render function の実行結果である仮想DOMツリーの差分のみを Real DOM に適用するシステム。 + +![virtual-dom](https://github.com/noshiro-pf/mono/blob/develop/articles/frontend-frameworks/virtual-dom.png?raw=true) + +### [Ember](https://emberjs.com/) + +テンプレート + +```html +
+

Count: {{count}}

+ +
+``` + +コンポーネント + +```js +import Component from '@glimmer/component'; +import { tracked } from '@glimmer/tracking'; +import { action } from '@ember/object'; + +export default class CounterComponent extends Component { + @tracked count = 0; + + @action + increment() { + this.count++; + } +} +``` + +- Glimmer というレンダリングエンジンを採用している。 + - 各コンポーネントを DOM 操作の命令列にコンパイルし、データの変更に応じて必要な部分だけを直接 DOM に変更を加える +- Ruby on Rails の開発者でもある Yehuda Katz と Tom Dale によって2011年に開発された。 + +### [Inferno](https://www.infernojs.org/) + +加筆予定 + +### [Solid](https://www.solidjs.com/) + +- 特徴 + - React の影響を受けたフレームワーク + - 仮想 DOM を使わず独自のリアクティヴシステムを採用しておりパフォーマンスに優れる + ![benchmark1](https://github.com/noshiro-pf/mono/blob/develop/articles/frontend-frameworks/benchmark1.png?raw=true) + ![benchmark2](https://github.com/noshiro-pf/mono/blob/develop/articles/frontend-frameworks/benchmark2.png?raw=true) + +```tsx +import { onCleanup, createSignal } from 'solid-js'; +import { render } from 'solid-js/web'; + +const CountingComponent = () => { + const [count, setCount] = createSignal(0); + + const timer = setInterval(() => { + setCount((count) => count + 1); + }, 1000); + + onCleanup(() => { + clearInterval(timer); + }); + + return
{`Count value is ${count()}`}
; +}; + +render(() => , document.getElementById('app')); +``` + +- React Hook のようなルールを理解する必要が無い + - Hook は、ループ、条件分岐、またはネストされた関数内で呼び出してはいけません。 + Hook は、常に React 関数のトップレベルで呼び出す必要があります。 +- すべてのコンポーネントは一度だけ評価（実行）され、依存関係が更新されるたびに実行されるのは hook と binding だけ + +見た目同じ動作をする React コンポーネント実装： + +```tsx +import * as React from 'react'; + +export const CountingComponent = () => { + const [count, setCount] = React.useState(0); + + useEffect(() => { + const timer = setInterval(() => { + setCount((c) => c + 1); + }, 1000); + + return () => { + clearInterval(timer); + }; + }, []); + + return
{`Count value is ${count}`}
; +}; +``` + +#### 使用時の注意点 + +リアクティヴシステムの仕組みを意識せねばならないシーンにちょくちょく遭遇する + +1. ダメな例 その1： props を destruct するとリアクティヴな値の伝播が途切れて正しく動かない + + ```tsx + const ViewComponent = ({ count }) => ( + // ~~~~~~~~~ + // Destructuring component props breaks Solid's reactivity; + // use property access instead. eslint(solid/no-destructure) +
{`Count value is ${count()}`}
+ // ↑ この値が 0 のまま動かなくなる + ); + + const CountingComponent = () => { + const [count, setCount] = createSignal(0); + // 中略 + return ; + }; + ``` + + 正しい実装（[`solid/no-destructure`](https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/no-destructure.md) という eslint ルールで自動修正可能） + + ```tsx + const ViewComponent = (props) => ( +
{`Count value is ${props.count()}`}
+ ); + ``` + +2. ダメな例 その2：（配列を JSX 内で `Array.prototype.map` などで展開してはダメ） + + ```tsx + const Component = (props) => ( +
    + {props.data.map((d) => ( +
  1. {d.text}
    2. + ))} +
+ ); + ``` + + 正しい実装（[`prefer-for`](https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/prefer-for.md)という eslint ルールで自動修正可能） + + ```tsx + const Component = (props) => ( +
    + {(d) =>
  1. {d.text}
    2. }     +
+ ); + ``` + +3. ダメな例 その3：（JSX 内で三項演算子などを用いてはダメ） + + ```tsx + const Component = (props) => ( +
{props.cond ? Content : Fallback}
+ ); + ``` + + 正しい実装（[`prefer-show`](https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/prefer-show.md)という eslint ルールで自動修正可能） + + ```tsx + const Component = (props) => ( +
+ Fallback}> + Content + +
+ ); + ``` + +これらの例が動かないのは、 Solid の状態管理で使われる `Signal` は純粋な Object ではなく、 [`Proxy`](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Proxy) から作られた特殊なObjectであることが原因です。 Proxy は Object の Getter と Setter の動作を乗っ取り、それらのプロパティの値が読まれたり、変えられたときに行う処理を改変する仕組みです。 + +例えば [Immer](https://immerjs.github.io/immer/#how-immer-works) は Proxy を使った JS の有名ライブラリの一つです。 immer の `produce` 関数が提供する `draft` オブジェクトは Proxy でできており、この `draft` に対する破壊的操作は `currentState` オブジェクトを改変することも丸ごと deep copy することもなく `nextState` を作ってくれます。 + +Solid ではこの Proxy をリアクティヴな変数を実現するために使用しており、そのためプログラマーは前述のような良くない例を踏まないようにリアクティヴィティを保つために慎重にコードを書く必要があります。配列の展開には ``、条件分岐には `` を使う必要があります。 + +ただし、数年前 Solid を試したときには eslint plugin が整備されていなかったか私が存在を認知していなかったので、リアクティヴィティを保つ実装に注意力が結構必要だなという印象を受けたのですが、いつの間にか自動修正含め色々整備されていたのでほとんど困ることはないかもしれません。 + +### [Svelte](https://svelte.jp/) + +- コンパイル時にコードを最適化する（仮想DOMを使用しない） + - 実行時のパフォーマンスが良く、バンドルサイズが小さい + +```html + + +
+

カウント: {count}

+

カウント x 2: {doubled}

+
{count % 2 === 0 ? "偶数" : "奇数"}
+
{#if count % 2 === 0}{:else}{/if}
+ +
+``` + +even.svelte + +```svelte +
+ Even +
+``` + +odd.svelte + +```svelte +
+ Odd +
+``` + +- 1ファイル1コンポーネントが強制される + - コードの治安が保たれるという見方もできる半面、わざわざファイルに切り出すまでもない小さな共通コンポーネントをローカルに繰り返し使いたいユースケースでちょっと不便になりそう。 + +### [Elm](https://elm-lang.org/) + +```elm +module Counter exposing (main) + +import Browser +import Html exposing (..) +import Html.Events exposing (onClick) + + +type Model = + { count : Int } + + +init : Model +init = + { count = 0 } + + +type Msg + = Increment + + +update : Msg -> Model -> Model +update msg model = + case msg of + Increment -> + { model | count = model.count + 1 } + + +view : Model -> Html Msg +view model = + div [] + [ p [] [ text ("カウント : " ++ String.fromInt model.count) ] + , button [ onClick Increment ] [ text "カウントアップ" ] + ] + + +main : Program () Model Msg +main = + Browser.sandbox + { init = init + , view = view + , update = update + } +``` + +加筆予定 + +### [PureScript](https://www.purescript.org/) + +```purescript +module Counter where + +import Prelude +import Effect (Effect) +import React.Basic +import React.Basic.DOM (div, p, button, text) +import React.Basic.Events (onClick) +import React.Hooks (useState) + +component = React.Basic.component "Counter" \ctx -> do + (count, setCount) <- useState 0 + + pure do + div [] do + p [] [ text $ "カウント : " <> show count ] + button [ onClick $ \_ -> setCount (add 1 count) ] [ text "カウントアップ" ] +``` + +加筆予定 + +### [ReScript](https://rescript-lang.org/) + +```rescript +import React from 'react'; +import * as ReactHooks from 'react'; + +@react.component +let make = () => { + let (count, setCount) = ReactHooks.useState(() => 0); + + let increment = () => setCount(prev => prev + 1); + +
+

{React.string( "カウント : " ++ string_of_int(count)) }

+ +
+}; +``` + +加筆予定 + +### [DIOXUS](https://dioxuslabs.com/) + +```rust +use dioxus::prelude::*; + +fn main() { + dioxus::desktop::launch(App); +} + +fn App(cx: Scope) -> Element { + let (count, set_count) = use_state(&cx, || 0); + + cx.render(rsx! { + div { + p { "カウント : {count}" } + button { onclick: move |_| set_count(count + 1), "カウントアップ" } + } + }) +} +``` + +加筆予定 + +### [Yew](https://yew.rs/) + +```rust +use yew::prelude::*; + +enum Msg { + AddOne, +} + +struct Counter { + count: i64, +} + +impl Component for Counter { + type Message = Msg; + type Properties = (); + + fn create(_ctx: &Context) -> Self { + Self { count: 0 } + } + + fn update(&mut self, _ctx: &Context, msg: Self::Message) -> bool { + match msg { + Msg::AddOne => { + self.count += 1; + true + } + } + } + + fn view(&self, ctx: &Context) -> Html { + html! { +
+

{ format!("カウント : {}", self.count) }

+ +
+ } + } +} + +fn main() { + yew::start_app::(); +} +``` + +加筆予定 + +### [Lit](https://lit.dev/) + +```tsx +import { LitElement, html, css } from 'lit'; +import { customElement, property } from 'lit/decorators.js'; + +@customElement('my-counter') +export class MyCounter extends LitElement { + static styles = css` + p { + color: blue; + } + `; + + @property({ type: Number }) count = 0; + + render() { + return html` +
+

カウント : ${this.count}

+ +
+ `; + } + + private _onClick() { + this.count++; + } +} +``` + +加筆予定 + +### [Qwik](https://qwik.dev/) + +```tsx +import { component$, useSignal } from '@builder.io/qwik'; + +export const Counter = component$(() => { + const count = useSignal(0); + + const increment = () => { + count.value++; + }; + + return ( +
+

カウント : {count.value}

+ +
+ ); +}); +``` + +加筆予定 + +### [Stencil](https://stenciljs.com/) + +```tsx +import { Component, h, State } from '@stencil/core'; + +@Component({ + tag: 'my-counter', + shadow: true, +}) +export class MyCounter { + @State() count = 0; + + render() { + return ( +
+

カウント : {this.count}

+ +
+ ); + } +} +``` + +加筆予定 + +### [HTMX](https://htmx.org/) + +加筆予定 + +--- + +## 筆者がフロントエンドフレームワークを選ぶなら + +以上、代表的なフロントエンドフレームワークについてまとめました。 + +筆者は、現在はメンテナンスしているすべてのフロントエンド実装に React か Preact を使用しています。使用時期や期間に差はありますが、過去には VanillaJS/jQuery や Angular なども実用アプリケーション開発に使用した経験（数千行以上）がありますが、今後当分は React/Preact を使うのが結論かなと考えています。 +そこで React をベースとして他フレームワークのどういうところに利点を感じるか、どういうところに不満を感じる（あるいは感じそう）かを考えてみたいと思います。 + +### パフォーマンス観点 + +パフォーマンス面を重視する場合、Solid, Svelte, Inferno, などが React と比べて特にパフォーマンスに優れているようですが、この中で選ぶなら私は **Solid** を選びたいかなと思います（今更宣言的 UI を捨てて Vanilla JS で書くという選択肢はほぼ無いでしょう）。 +**Inferno** は syntax が class component で記述する旧 React に近く、 hooks と関数コンポーネントで記述できる React 等と比べてあまり書きやすくはなさそうです。仮想DOMの実装が bit 演算を使用することなどにより React より高速化されているらしく、十分高いパフォーマンスを示していますが、仮想DOMを使っていることには変わりが無いので、リアクティヴィティを直接管理しようとする Svelte や Solid と比べると、ランタイムパフォーマンス・バンドルサイズで僅かに劣るようです。 +**Svelte** はコンパイル時にコードを最適化しますが、結局 Solid と同じように仮想DOMを使わずにリアクティヴな値の伝播を管理する点では本質的な動作は同じものになると考えられ、パフォーマンス面で大きな優劣は付かないのではないかと思います。benchmark では僅かに Solid が勝るようです。また、小さなローカルコンポーネントを記述することがおそらくできないため柔軟性に若干欠けるような気もします。 +**Solid** は React hooks に慣れた開発者にとってこの3つのうち最も親和性の高い選択肢だと思います。先述の通り JSX 記述時にいくつかの注意点がありますが、代わりに `useMemo`, `useCallback` hooks などや `React.memo` などによりメモ化のためのコードを記述する手間を大幅に削減できるため開発体験が非常に良さそうです。 Svelte と異なり、 Solid は（Svelteと同じくコンパイラでもありますが） TypeScript 上で使用するライブラリであるため、 Syntax Highlighting がしやすいという利点もあります。 + +ただ、これまで経験上 React のレンダリングエンジンだと遅くてどうしようもないから他を使いたい、という状況に遭遇したことがほとんど無いため、パフォーマンスを改善するためにReact 以外のフレームワークを使う強い動機は持ち合わせていないというのが正直なところです。 +結局、宣言的UIとコンポーネントを実現する上での選択肢は + +- rendering のたびにコンポーネントツリーを全部再計算してしまう（適宜メモ化する）が、仮想DOMを挟むことで差分を取って DOM に反映するところだけ最適化する（React, Preact などのやり方） +- 不要な再計算を省くために、自動的にリアクティヴに再計算する対象をコードとして記述し管理する（Solid や Svelte のやり方） + +の二択になりそうで、後者はリアクティヴィティのための記述がどうしても発生することになるため、パフォーマンスとコード記述量のトレードオフが存在するのが現状なのかなという気がするのですが、それならばパフォーマンス面の要求が相当強くならない限りは syntax の良し悪し（場合によっては慣れ）を優先して良いのかな、という気持ちです。 + +その点、 React との親和性の高さとパフォーマンス・省バンドルサイズを両立できる選択肢として **Preact** も有力です。独自リアクティヴシステムを持つ Solid, Svelte ほどの理論値は追求できませんが、 多くの場合実用上十分なのかなと思っています。react との親和性を重視して作られており、適切に import 先の alias を設定することで React 製のライブラリを流用できる点が魅力です。実際私はいくつかのアプリケーションでは現在も採用しています。自分が Solid を採用する場合は実用上の要求というよりは技術的興味が大きな理由となりそうです。 +**Vue**, **Angular** はいくつかの benchmark 上 React より優れていますが Preact や Solid ほどではなく、syntax の観点でデメリットが大きいと感じるため自分が採用する可能性はほぼ無さそうです。 + +### Syntax 観点 + +component や hooks をメモ化する手間が無いこと、 hook の記述ルールの少なさで Solid は優れていますが、代わりに React や Preact には無い Proxy オブジェクトの維持にまつわる JSX 内の記法の制約が生じるのが若干煩わしいような気もします。制御構文のための `For` や `Show` などの import の手間も気になるのかなと思いましたが、これは `useMemo` や `useCallback` などの import の手間との取引なので優劣はあまり付かないかなと思います。 + +メモ化のためのボイラープレートコードのうちフックを使うものは、グローバルステートに状態管理を寄せることで、コンポーネント内にコールバック関数やリアクティヴな変数を持たずに済むようにすることで大部分を回避することができます。そうなると、`React.memo` だけがボイラープレートとして残ることになりそうです。 + +加えて、React の場合は現在 [React Compiler](https://ja.react.dev/learn/react-compiler) というものがベータ版で提供されており、 `useMemo` や `React.memo` などによるメモ化のためのコードを自動で挿入することができるようです。まだ試せていないのですが、これを最大限活用できれば、メモ化のための多くの記述を完全に省いた React 関数コンポーネントは（`` や `` などの JSX 内制御構文を必要とする）Solid に比べても真に少ないコンポーネント記述・import を実現できるので、 TypeScript の範疇でのフロントエンド実装の syntax の最適解の一つとなりそうな予感がします。 + +### 言語 + +TypeScript には JavaScript のスーパーセットであるという明確な利点がありますが、を使う以上どうしても JavaScript の負債も引き継ぐことになってしまうため、より洗練された堅牢性・保守性に優れた言語を使いたい場合は他の言語を検討する手もありそうです。 + +TypeScript よりも安全な言語でフロントエンドを構築したい場合に、 Elm, PureScript, ReScript などの純粋関数型言語を採用するのは有力です。 ReScript は比較的 JavaScript エンジニアが親しみやすい syntax をしているのと、比較的可読性の高い JS/TS コードを出力することが一応できるため移行のハードルが他二つよりは低いです。ただ、試した感じだと自分の手で書いたコードを置き換えられるほどのクオリティのコードは吐いてくれないため、 React&TypeScript プロジェクトの一部コードから置き換えていくような使い方はあまりする気にはなりませんでした。 + +Rust を使うタイプのフロントエンドフレームワークは、バックエンドにも Rust を使う場合などに言語を統一する選択肢として面白そうです。 使用できるかどうかは [WASM Browser Compatibility](https://developer.mozilla.org/en-US/docs/WebAssembly#browser_compatibility) を確認する必要があるかもしれません。 WASM のバンドルサイズが大きいというデメリットがあるらしいのと、マクロによる記述がエディタで補完が効きづらく書きづらいという噂を聞いたことだけあるので、このあたり詳しく調べてみようと思います。 + +結局抜き差しならない問題として、コンポーネントライブラリ（[Material UI](https://mui.com/material-ui/?srsltid=AfmBOormP6d7WQO8yFX4g1sLIYwFSP5IkFbXkelCkVuTNcN99900hDvz) や [Blueprint](https://blueprintjs.com/docs/) など）などで React 向けのものを使いたいとなるとReact を選んでおくのが無難になりやすいと思います。デザインは自作で済むなど外部依存無く実装できることが分かっている状況では、それ以外のフレームワークを採用する可能性がありそうです。 + +## TODO + +- benchmark のコードを詳しく読んでみる + - 公平な比較になっているのか自分の目で確認したい +- Vanilla JS/jQuery による命令的 UI は何がつらかったのかを言語化してみる + - 本記事では宣言的UIを実現するもののみを比較していたため +- Rust を使うタイプのフロントエンドフレームワークについて詳しく調べる diff --git a/articles/frontend-frameworks/benchmark1.png b/articles/frontend-frameworks/benchmark1.png new file mode 100644 index 0000000000000000000000000000000000000000..784022be1d4ee1f611bf2224bdddf2f859204d95 GIT binary patch literal 85620 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 z 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 z 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 C)G0s! literal 0 HcmV?d00001 diff --git a/articles/frontend-frameworks/virtual-dom.png b/articles/frontend-frameworks/virtual-dom.png new file mode 100644 index 0000000000000000000000000000000000000000..e89cbf958f0afd4e2da8cec7a5f7e021f006ee84 GIT binary patch literal 47040 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 literal 0 HcmV?d00001 diff --git a/articles/take-full-advantage-of-typescript-eslint.md b/articles/take-full-advantage-of-typescript-eslint.md index 84fabb1986..9f67c600ee 100644 --- a/articles/take-full-advantage-of-typescript-eslint.md +++ b/articles/take-full-advantage-of-typescript-eslint.md @@ -727,7 +727,7 @@ JavaScript の `Array.prototype.sort` はデフォルトで文字列比較によ ``` この ESLint ルールを有効にすると `.sort()` の引数を省略できないようになります。 -文字列の配列に関しては比較関数省略時のデフォルト動作が自然であり採用したい場合が多いので、 `ignoreStringArrays` option も有効にしておくのが有効です。 +文字列の配列に関しては比較関数省略時のデフォルト動作が自然であり採用したい場合が多いので、 `ignoreStringArrays` option も有効にしておくと便利です。 ```json { diff --git a/articles/typescript-branded-type-int.md b/articles/typescript-branded-type-int.md index d058cc6c56..cb8ab3c82e 100644 --- a/articles/typescript-branded-type-int.md +++ b/articles/typescript-branded-type-int.md @@ -9,29 +9,31 @@ published: true ## 更新履歴 - （2025/01/11） 「Branded Type を使用したときの弊害」を追記 -- （2025/01/20）コード例の一部で tag 部分に `never` 型を用いていたのを `unknown` 型に修正 +- （2025/01/20）コード例の一部でBrand 型のオブジェクト部分に `never` 型を用いていたのを `unknown` 型に修正 - 参考： [誤解されがちなnever型の危険性: 「存在しない」について](https://qiita.com/uhyo/items/97941f855b2df0a99c60?utm_campaign=post_article&utm_medium=twitter&utm_source=twitter_share) ## 概要 -TypeScript で用いられることのある Type branding というハックと既存のいくつかのライブラリでのその実装例を説明し、次に、より安全かつ便利に Type branding を使うためのユーティリティの実装や ESLint 設定も紹介します。 +TypeScript で用いられることのある Type branding というハックと、既存のいくつかのライブラリでのその実装例を説明し、次に、より安全かつ便利に Type branding を使うためのユーティリティの実装や ESLint 設定も紹介します。 最後に Type branding の活用例として、数値型を `number` より細かく使い分けられるように Branded Type を定義する実装例を載せています。 Branded Type のよくある実装に、筆者が最近思いついたちょっとした工夫を入れることで数値型の Branded Type を上手く実装できたので紹介してみました。 + + ## Type branding とは -Structural Typing を採用している TypeScript では、例えば複数の異なる ID 文字列の型 （`UserId`, `ProjectId`, ... ）を区別したいというような状況で、以下のように type alias を作っても、単なる string と同等に扱われてしまい区別できません。 +Structural Typing を採用している TypeScript では、例えば複数の異なる ID 文字列の型 （`UserId`, `PostId`, ... ）を区別したいというような状況で、以下のように type alias を作っても、単なる string と同等に扱われてしまい区別できません。 ```ts type UserId = string; -type ProjectId = string; -type Project = { id: ProjectId; name: string }; +type PostId = string; +type Post = { id: PostId; name: string }; -declare function findProject(id: ProjectId): Promise; +declare function findPost(id: PostId): Promise; const userId: UserId = 'user-1'; -// userId を使って findProject を呼んでいるがエラーにならない -findProject(userId); +// userId を使って findPost を呼んでいるが型エラーにならない +findPost(userId); ``` しかしこのような問題を解決するための手段として **Type branding** というハックが知られています。 @@ -40,20 +42,21 @@ Type branding を用いると、以下のようにしてそれぞれの id 型 ```ts type UserId = string & { UserId: unknown }; -type ProjectId = string & { ProjectId: unknown }; -type Project = { id: ProjectId; name: string }; +type PostId = string & { PostId: unknown }; +type Post = { id: PostId; name: string }; -declare function findProject(id: ProjectId): Promise; +declare function findPost(id: PostId): Promise; const userId: UserId = 'user-1' as UserId; -// Argument of type 'UserId' is not assignable to parameter of type 'ProjectId'. -findProject(userId); +findPost(userId); +// ~~~~~~ +// Argument of type 'UserId' is not assignable to parameter of type 'PostId'. userId.slice(); // userId は通常の string でもある ``` -Type branding とは、対象となる型（この例では `string`）に `{ tagName: unknown }` という実際の値とは無関係のダミーのオブジェクト型を交差型として付け加えることで、構造上の互換性を破るテクニックです。こうすることで作られた型（Branded Type） `userId` はただの string 型とは異なる型になり、この例における `findProject` を呼び出してしまうようなミスを防ぐことができるようになります。 +Type branding とは、このように対象となる型（この例では `string`）に `{ brandTag: unknown }` という実際の値とは無関係のダミーのオブジェクト型を交差型として付け加えることで、構造上の互換性を破るテクニックです。こうすることで作られた型（Branded Type） `userId` はただの string 型とは異なる型になり、この例における `findPost` を呼び出してしまうようなミスを型チェックで防ぐことができるようになります。 ## Branded Type の様々な実装 @@ -61,7 +64,7 @@ Type branding とは、対象となる型（この例では `string`）に `{ ta [io-ts](https://github.com/gcanti/io-ts/blob/master/index.md#branded-types--refinements)[^io-ts] -[^io-ts]: io-tsでは、`Brand` という型により unique symbol をキーに持つオブジェクト型にネストさせることで、カスタム実装した型定義や他のライブラリ製の branded type との衝突を防ぐ仕組みになっています。本記事の Branded Type 定義では分かりやすさのためこのような実装はせずに説明しました。 +[^io-ts]: io-tsでは、`Brand` という型により `unique symbol` をキーに持つオブジェクト型にネストさせることで、カスタム実装した型定義や他のライブラリ製の branded type との衝突を防ぐ仕組みになっています。本記事の Branded Type 定義では分かりやすさのためこのような実装はせずに説明しました。 ```ts declare const _brand: unique symbol; @@ -79,21 +82,23 @@ type Int = number & Brand<{ readonly Int: unique symbol }>; type Int = number & { __type__: 'Int' } & { __witness__: number }; ``` -どちらの方法も型を区別するという要件は満たせますが、 tag object の key 部に型 ID を置く前者のやり方の方が、以下のように `&` で意味のある交差型を作ることができる点で便利そうです（後者の方法では `never` に潰れてしまいます）。 +どちらの方法も型を区別するという要件は満たせますが、オブジェクト型の value 部に型 ID を書く ts-brand の方法は、 `__type__` などのタグ名を予約するというルールが増えてしまうのも少し気になりますし、key 部に型 ID を置く io-ts のやり方の方が、以下のように `&` で意味のある交差型を作ることができる点で便利そうです（ts-brandの方法では `never` に潰れてしまいます）。 ```ts -type Int = number & { Int: unique symbol }; -type Positive = number & { Positive: unique symbol }; -type PositiveInt = Positive & Int; // number & { Positive: unique symbol } & { Int: unique symbol } +type Int = number & { Int: unknown }; +type Positive = number & { Positive: unknown }; +type PositiveInt = Positive & Int; // number & { Positive: unknown } & { Int: unknown } ``` -また、後者の tag の value 部に型 ID を書く方法は、 `__type__` などのタグ名を予約するというルールが増えてしまうのも少し気になります。 +また、その場合の value 部の型は `any` や `never` ではなく `unknown` や `unique symbol` にしておくのが良さそうです。こうしておけば、上の `Int` 型で宣言した変数 `a` に対して `a.Int` のようにプロパティアクセスしてしまっても、その結果が `unknown` 型にしかならないため間違ってどこかで使ってしまうリスクが他の型よりは低くなります。 -今回は前者の key 部に型 ID を書く方法が都合が良いので以降はこちらを採用します。 +また、これをより安全にするために key 部を `unique symbol` で実装することでそもそものプロパティアクセスもできなくしてしまうという方法があります（[Branded Type ベストプラクティス 検索](https://qiita.com/uhyo/items/de4cb2085fdbdf484b83) でベストプラクティスとされているやり方です）。 + +なお、本記事の `## ［応用］ Branded Type で数値型を細分化` の実装では `unique symbol` を key にすることも可能ですが、コードが長くなり分かりづらくなってしまうことを避けるため、単に文字列リテラル型を用いたコード例で説明しています。また、 value 部で述語を表現できるようにするため、意図的に `unknown` や `unique symbol` ではなく `boolean` 型を使用しています。 ## より安全に Branded Type を使う方法（型ガード関数の定義、ESLint 設定） -Branded Type で変数に型注釈を付けるときには一つ不安要素があります。それは `as` によるキャストが嘘である可能性があることです。 +Branded Type で変数に型注釈を付けるときには一つ不安要素があります。それは `as` によるキャストが嘘になる可能性があることです。 ```ts type Int = number & { Int: unknown }; @@ -104,7 +109,7 @@ function numberToString(n: number, radix?: Int): string { return n.toString(radix); } -numberToString(12345, r); +numberToString(12345, r); // Uncaught RangeError: toString() radix argument must be between 2 and 36 ``` これを多少改善するために、 Branded Type 定義と共にガード関数と生成関数をセットで用意する方法が考えられます。 `as` を使ったキャストは unsafe ですが、以下のようにすると型名に合う値であることを保証しやすくなります。 @@ -118,16 +123,16 @@ function isInt(a: number): a is Int { return Number.isInteger(a); } -function toInt(a: number): Int { +function castToInt(a: number): Int { if (!isInt(a)) { - throw new Error(`a non-integer number "${a}" was passed to "toInt"`); + throw new Error(`a non-integer number "${a}" was passed to "castToInt"`); } return a as Int; } // main.ts -const r: Int = toInt(0.1); // ここで早期にエラーで気づける +const r: Int = castToInt(0.1); // ここで早期にエラーで気づける function numberToString(n: number, radix?: Int): string { return n.toString(); @@ -155,7 +160,7 @@ export type Int = z.infer; export const isInt = (a: number): a is Int => Int.safeParse(a).success; -export const toInt = (a: number): Int => Int.parse(a); +export const castToInt = (a: number): Int => Int.parse(a); ``` [io-ts](https://github.com/gcanti/io-ts/blob/master/index.md#branded-types--refinements) の使用例：[^io-ts-int] @@ -178,7 +183,7 @@ export type Int = t.TypeOf; export const isInt = (a: number): a is Int => E.isRight(Int.decode(a)); -export const toInt = (a: number): Int => { +export const castToInt = (a: number): Int => { const ret = Int.decode(a); if (E.isLeft(ret)) { throw new Error(ret.left.toString()); @@ -187,7 +192,7 @@ export const toInt = (a: number): Int => { }; ``` -もちろん、これだけでは `toInt` や `isInt` などのユーティリティを使わず `as Int` と書いてしまうことを禁止できているわけではないので、さらに ESLint によりチェックすると良さそうです。 +もちろん、これだけでは `castToInt` や `isInt` などのユーティリティを使わず `as Int` と書いてしまうことを禁止できているわけではないので、さらに ESLint によりチェックすると良さそうです。 以下のように設定することでこれをチェックできます。 @@ -200,14 +205,14 @@ export const toInt = (a: number): Int => { "error", { "selector": "TSAsExpression[typeAnnotation.typeName.name='Int']", - "message": "use toInt or isInt instead" + "message": "use castToInt or isInt instead" } ] } } ``` -## Branded Type を使用したときの弊害 +## Branded Type を使用したコードの弊害 Branding は TypeScript でのコーディングにおいて便利な道具ですが、あくまでユーザー側で慣例的に行われている「ハック」であり[^type-branding-is-hack]、TypeScriptに公式にサポートされている実装パターンというわけではないことに注意が必要です。 @@ -216,7 +221,8 @@ Branding は TypeScript でのコーディングにおいて便利な道具で 具体的には、例えば以下のようなコードで好ましくない挙動に遭遇します。 ```ts -type SafeUint = number & { readonly SafeUint: unknown }; +// 非負整数型 +type Uint = number & { readonly Uint: unknown }; const findIndex = (xs: readonly number[], x: number): number => xs.indexOf(x); @@ -229,26 +235,26 @@ const fn1 = (): 0 | 1 | undefined => { return undefined; }; -const findIndexBranded = (xs: readonly number[], x: number): SafeUint | -1 => - xs.indexOf(x) as SafeUint | -1; +const findIndexBranded = (xs: readonly number[], x: number): Uint | -1 => + xs.indexOf(x) as Uint | -1; const fn2 = (): 0 | 1 | undefined => { - const i: SafeUint | -1 = findIndexBranded([], 1); + const i: Uint | -1 = findIndexBranded([], 1); if (i === 0 || i === 1) { - // `i` は `0 | 1` 型に絞られず SafeUint のまま！（`-1` だけは除去される） - return i satisfies SafeUint; - // ~~~~~ + // `i` は `0 | 1` 型に絞られず Uint のまま！（`-1` だけは除去される） + return i satisfies Uint; + // ~~~~~~~~~~~~~~~~~~~~ // Type Error } return undefined; }; ``` -このコードにおいて、普通の `number` 型を使っている一つ目の例 `fn1` ではうまく型の絞り込みができますが、二つ目の例の `fn2` のようにbrand 化した `number` 型である `SafeUint` 型は `number` のサブタイプであるため、即値 `0`, `1` との比較による絞り込みができないという悩みが生じます。 +このコードにおいて、普通の `number` 型を使っている一つ目の例 `fn1` ではうまく型の絞り込みができますが、二つ目の例の `fn2` のようにbrand 化した `number` 型である `Uint` 型は `number` のサブタイプであるため、即値 `0`, `1` との比較による絞り込みができないという悩みが生じます。 -この絞り込みに失敗するのは、 `number` 型は型 `0` や型 `1` の上位型であるのに対し、 brand 型 `SafeUint` は型 `0` や型 `1` の上位型ではないことが理由です。条件部で `SafeUint & 0` 型の即値との比較などができれば `SafeUint` の部分型であるため絞り込みができそうですが、行いたい処理の割にコードが複雑化・コード量が増えるのがネックです。 +この絞り込みに失敗するのは、 `number` 型は型 `0` や型 `1` の上位型であるのに対し、 brand 型 `Uint` は型 `0` や型 `1` の上位型ではないことが理由です。条件部で `Uint & 0` 型の即値との比較などができれば `Uint` の部分型であるため絞り込みができそうですが、行いたい処理の割にコードが複雑化・コード量が増えるのがネックです。 -ちなみにこの例のようなケースは、部分的に `i` を `SafeUint` から `number` 型に広げてから即値との比較を行うという手はあります。関数内のローカル変数 `i` の型から `SafeUint` 型という情報が落ちるくらいは許容できそうです。 +ちなみにこの例のようなケースは、部分的に `i` を `Uint` から `number` 型に広げてから即値との比較を行うという手はあります。関数内のローカル変数 `i` の型から `Uint` 型という情報が落ちるくらいは許容できそうです。 ```ts const fn2_2 = (): 0 | 1 | undefined => { @@ -297,7 +303,7 @@ interface Array { こういった事情もあり、整数を使うべき箇所でもほぼ浮動小数点数 `number` を（諦めて）使っていることがほとんどです。 また、整数しか入力として想定していないような関数を定義するときも仮引数に `number` 型を使わざるを得ない以上、ちゃんとやるなら `Number.isInteger` などでチェックするバリデーションコードを関数の初めに書くべきではあるのですが、いちいちバリデーションを書くのは手間ですし、どうせすべての箇所で厳密にやるのが現実的にほぼ無理ということで、特に重要な場合以外は省いてしまうことも多そうです。 そもそも、型を信じることで（TypeScript の型による保証は絶対ではないので、信じられるように注意してコードを書くことで）そういったバリデーションコードをすべての関数に都度書く手間とランタイムコストを省けるのが JavaScript と比較したときの TypeScript の大きなメリットの一つであるはずなので、数値型の制約も型でなるべく保証できている状態が自然に思えます。 -特定の条件を満たす数値型（整数など）だけを受け取る関数では、それを**型で明示してある方が、関数にバリデーションコードを書く手間とランタイムチェックコストを省ける上に関数のインターフェースも分かりやすくなる**メリットがありそうです。 +特定の条件を満たす数値型（整数など）を受け取る関数は、それを型で明示してある方が関数にバリデーションコードを書く手間とランタイムチェックコストを省ける上に関数のインターフェースも分かりやすくなるメリットがありそうです。 そこで、今回は組み込みの `Number` オブジェクトに生えている各種バリデーション関数に対応する Branded number type を実装することにします。 @@ -325,7 +331,7 @@ type PositiveNegativeNumber = PositiveNumber & NegativeNumber; // できれば never になってほしい。 ``` -そこで、以下のように **Branded Type の tag 部の value に `unknown` ではなく `true/false` を持たせる**という工夫を考えてみました。 +そこで、以下のように **Branded Type のオブジェクト型の value に `unknown` ではなく `true/false` を持たせる**という工夫を考えてみました。 ```ts type PositiveNumber = number & { Positive: true }; @@ -334,7 +340,7 @@ type NegativeNumber = number & { Positive: false }; type PositiveNegativeNumber = PositiveNumber & NegativeNumber; // never ``` -こうすると、 `true & false` が `never` なので全体も `never` になってくれます。意味的には、 tag が表す述語が真になる場合は `true` 、偽になる場合は `false` を割り当てる、という風にして型を分類しています。 +こうすると、 `true & false` が `never` なので全体も `never` になってくれます。意味的には、オブジェクト型の key が表す述語が真になる場合は `true` 、偽になる場合は `false` を割り当てる、という風にして型を分類しています。 正確には `0` や `NaN` が含まれないようにもしたいため、もう少し意味的に正確な型になるよう修正してみます。 @@ -357,11 +363,7 @@ type NegativeNumber = number & { 直接書いても良いのですが、 Branded Type を作る型ユーティリティも用意してみます。 ```ts -export type Brand< - T, - TrueKeys extends string, - FalseKeys extends string = never, -> = T & { +type Brand = T & { readonly [key in FalseKeys | TrueKeys]: key extends TrueKeys ? true : false; }; ``` @@ -376,7 +378,7 @@ type NegativeNumber = Brand; 第 3 引数のデフォルト値を `never` にしているので、冒頭の例のような `false` な key を使う必要の無い普通のケースは 2 引数で書けるようにもしています。 ```ts -type ProjectId = Brand; // string & { readonly ProjectId: true }; +type PostId = Brand; // string & { readonly PostId: true }; ``` これを使うと数値型を以下のように実装できます。 @@ -384,51 +386,47 @@ type ProjectId = Brand; // string & { readonly ProjectId: t ```ts import { type Brand } from './brand'; -export type NaNType = Brand; +type NaNType = Brand; -export type FiniteNumber = Brand; +type FiniteNumber = Brand; -export type InfiniteNumber = Brand; +type InfiniteNumber = Brand; -export type POSITIVE_INFINITY = Brand< +type POSITIVE_INFINITY = Brand< number, 'NonNegative', 'Finite' | 'NaN' | 'Zero' >; -export type NEGATIVE_INFINITY = Brand< +type NEGATIVE_INFINITY = Brand< number, never, 'Finite' | 'NaN' | 'NonNegative' | 'Zero' >; -export type NonZeroNumber = Brand; +type NonZeroNumber = Brand; -export type NonNegativeNumber = Brand; +type NonNegativeNumber = Brand; -export type PositiveNumber = Brand; +type PositiveNumber = Brand; -export type NegativeNumber = Brand< - number, - never, - 'NaN' | 'NonNegative' | 'Zero' ->; +type NegativeNumber = Brand; -export type Int = Brand; +type Int = Brand; -export type Uint = Brand; +type Uint = Brand; -export type NonZeroInt = Brand; +type NonZeroInt = Brand; -export type SafeInt = Brand; +type SafeInt = Brand; -export type SafeUint = Brand< +type SafeUint = Brand< number, 'NonNegative' | 'Finite' | 'Int' | 'SafeInt', 'NaN' >; -export type NonZeroSafeInt = Brand< +type NonZeroSafeInt = Brand< number, 'Finite' | 'Int' | 'SafeInt', 'NaN' | 'Zero' diff --git a/articles/typescript-range-type.md b/articles/typescript-range-type.md index 7c65290b99..82ccf27a22 100644 --- a/articles/typescript-range-type.md +++ b/articles/typescript-range-type.md @@ -1,13 +1,11 @@ --- -title: 'TypeScript で連番の配列に詳しい型を付ける' +title: '［型パズル］TypeScript で連番の配列に詳しい型を付ける' emoji: '🐈' type: 'tech' # tech: 技術記事 / idea: アイデア -topics: ['typescript'] -published: false +topics: ['typescript', 'type-challenges'] +published: true --- -[TypeScript Playground WIP](https://www.typescriptlang.org/play?#code/C4TwDgpgBAqglgO2ADigXigSQQEwgDwB4AmAVgDYA+AbgChaAzAVwQGNg4B7BKAJwEMEAcwgBBXgJCEAylALAIuAM6xEKADRQAonPwLlqpMkoAKWlChLg-XsABcUaevNzcDrc4tWIYAPwOARloASgcAJUERABk4KxlNLRp6ZjYObj5IsQl+EDMva1sHBCYAWwAjCF5PVxwi0oqql28-OvLKkIdeCH4cbgAbEChitt4AbQBdOkYWdi4eAWEsyTzLAvsh+srqxVqNkerm1ob0KCDQvm7ehAG9homoAG8XLuAmXh5xSQA6Bl5OEpMCxEJisNmAmh2mmawWCdAAvskZmkEAAqDKLFagwq3LYuHZHXH5HwE3gnM4OADiikq-GAnF4hGGDU0ADdOHAcJoWABrBCcADuCEojxcDHpUBMfQgwCgcBJJyxwGoqx8UGFAAYoL5ZVBCDUoA44GqasqjQBqDDQkUWCwgOAQPo4WV0CwIhG0VjcKwXJRMPrAAKdS79QajAKaYiaADMmgALOMTkCljkTOGoKRYVAAPRZqCcbker2cKVfPqcISAiC+-0BTM5qBhiPRuPjeiehDelQYYhQfgqAJQAA+UB7w6jdHb3ugGHIvZUpCHUFnw4A7BOvTKutXgMQgz0QxKB8PR1Ao4vY4uF8PyMF7hgk58U0oIbDCx3ixBS+XK9viHXc6MkannGmikK29BZmioCQLKJRgFKJSKNYyJQCiWb0NB0ARIsMRxLI8g7Co8BGAkuj6DgRFqMYJwAEKcMWADyDIuHRjEMpgSgAHIQCylQyJQmgcdxvEMokAnZrmTjaFAgB2DIAIgyAFoMgAxDIA0gyADIMUCaoAgZGAAS+MlQCwcyyYALBqABAqLH0X0TGEBxMAIHM-GCUodkOWJFj1lJOjycp6lqmgPa6fphnpDJZm0MKBEGMAvBMBALjal0+7XIMWj4KwfRMHghBRFoACKoxaOMmg5flACyiD8eMlD3PWwU8IA1gyAH-agDqDIAZgyOBAACOUCAOYMgDR6oAEFGAOnegCaDIA0QyABYMgCADIACr6ADnmamAMbWzWAPIMgBWDHJMk9VNgC6DDJgB7aoA-gkyYA+gyAIEMLgONI3JwGA8QdZ1hBiVMtCYVArFWQyohkYRUBlJZ3QIJoNE-QY-0foIwoYKMogJpFFENgw-B9EoECthY2qjDRcN6L9oxIyjaPxVABOo5dUDRbF5OUxAUxvUJPF8QAKlDDZMzj5EqKMCCM7wCbajTBok8jqN0+A0C2fZ3CEDArMAPqS3MmBwX0MtJLQkFogAAmolQIMjqHoW9CvOVLCDK-BMuaAA0qDCMwCcssnKMMAc3jPMiejWrC4T5O2-DKg8nygrEwzIlPWlGVZTANuUBFuNRTFcUYz7ZMWA4NPkx7lRizB5UIIQnF25RRjy-nFuq5xmgTOrxvlyrhAuEXAc4o0FhM8XFxJTcQcCggEzhScYd8Zx8ecxTSfE9nvDk0zowAORSsIwAABbz27BiccTc+L4oQir+v5Ny-XltVw26qaF8V-s7X4tQCVJxPBYiVXDcoxF4ghgoOMDjYHgRCj3hLnCWuACCF07kySorM-4EAYgwJmTB4IQEIKVfg3IIAIKQYQXugpNCj1vjBGB+A4GYKlIQDuLcX4Hhwf3KqJwFagOIfAxBUoK7kPVprKAOskB6wNmhV6d8GH-xISwiAbCXAUITgjKhyUDIIF5H3CY1RbYYHQSATgDAoBM0HhgDiAAxOA+AIA4CiHvVeuFgDsM7pnFO-spEqDURorRxM7HjwAAYABIHiQN4HCNx29OCcU2Aya2lAs683CSJLOwTgFYCUAYoxJizErwseQzuMie7yODrQqGLgfGdx3kvfea9+ap2gBnJOsSmaBOCTITunjvHBL8azfC9ioANMQAwSoUBm5tJ8X44mW905DF5rE1B6DSHIKZngiBwSy5oIwaI7ACh3giy+OMxZSDxHt2qA0ziAyOEom1rrVZfRDa0H1ohJQYB+CsGgMfBZkzlm8JRtaCmd8AAicAhBwBlBgTUw4jwjkXGeYcF5hxXiXIuFci5UDDgAJxTAsG9Jm-A4Cq0kePKwvBEBCFZpi36DSvk-OAHCLxnTukwD8d7B2RRRn0GRXfAxvA4gEoMNi3F+L6nkoQF00kVKvGovRew6l2paUjJEki95MFiW-OkNFE4RLvm-L8VKlF6LkEuHbuk4MsiaFKK1T0zusqZTDhNfK0kw554BHVPPRcNqXCs1GIajJoYiout1W-K+Xx2bVGfp60M3rplQCDe6m0XdX6BuvpfaNIbr5hptK6hsQaY0+tTcG0NfqI0HlGCmuNab80ZtjZmj13co0FrzZW4t1afUJv9WW5NNai0Vqbem9Ndbs2yNza2wtbbe39qrbWrNSbu0trHc2idfbB0To7SO6dU6e3zoHU2r24x36TAZboMA9IZRvQ2U8huhrpmGt6Vi6KuKs0AA0dUNv1QmaGXtWYcuEJ3IZNptTT0NQ4U9v157z0NdqS9X6oDMriKPTuFL+UAdgMa5VwALXQf3UshuwahWV3EnO6+GrCCjF9bAcSQbsOXs0DaygVVgOfvDXSyVtB3RvWkF1cBLcfHywY51NhgCIJHK4Sc-WZz+HGzY9so1zHgnVDZdIgNciFGCjvFAJDWCaF4LCazJ+iapOjCNJ-Rxmj2aGm5Y0kYoqtE1JGIQOAwpqM5xcHCWJ11bpMb6WJrRN7I3SeyTXeh9mwDCarhI6oI7WyHOOTw055zBM3R84eiwP6DA+PE656hWTFEJrCIlvVyXZNBcfi4dUDgmYulOA4OW3mOOaDQ+wzQI6AASlxKv5rCFVeEuH0tv1KZqcIC8ikHw3gjIu2oOunA3RhO+tWehpMoVJu9mgPknGnlyybDbnUWEg1AYjLhvWVlvZl2hwRaBe0A+TD5VS0Wq2+ottzd7WbnbaYF4md3hk3fHiOpT+bVuNeJmEANhAwhhOGV9sthBRBJCAA) - ## 目標 以下の返り値型の `rangeArray` 関数を実装すること。 @@ -19,26 +17,30 @@ function rangeArray( step: number = 1 ): /* TODO */; -const result: readonly [1, 2, 3, 4] = range(1, 5); // ok +const result: readonly [1, 2, 3, 4] = rangeArray(1, 5); // ok console.log(result); // [1, 2, 3, 4] ``` -`start` と `end` が（型計算が重くならない）十分小さな非負整数で `start <= end` かつ `step = 1` が満たされる場合には、返り値に `number[]` ではなく `[1, 2, 3, 4]` というより詳しい型を付ける、というのが今回やりたいことです。 +`start` と `end` が（型計算が重くならない）十分小さな非負整数で `step = 1` が満たされる場合には、返り値に `number[]` ではなく `[1, 2, 3, 4]` のようなより詳しい型を付ける、というのが今回やりたいことです。 + +## 完成品 + +[TypeScript Playground](https://www.typescriptlang.org/play/?#code/C4TwDgpgBAqglgO2ADigXigSQQEwgDwB4AmAVgDYA+AbgChaAzAVwQGNg4B7BKAJwEMEAcwgBBXgJCEAylALAIuAM6xEKADRQAonPwLlqpMkoAKWlChLg-XsABcUaevNzcDrc4tWIYAPwOARloASgcAJUERABk4KxlNLRp6ZjYObj5IsQl+EBMrG3soBCYAWwAjCF5NRRwHYvLKzW8-OtKK3lCitsqAbQBdOkYWdi4eAWEsyTzrW1aGqtdarvmmhTA59vQoAM769v6oAG8XXghgJl4ecUkAOgZeThKTcZFpgurcVZ9g4LoAX2SwzSCAAVBkJmYvDNCntGi4ahs4VCfIjeFsgp0AOKKSr8YCcXiEWELABunDgOE0LAA1ghOAB3BCUI4uBgEqAmAA2ZygcFRW3ytmoljWUGZAAYoL5eVBCIsoA44GLFsKlQBqDDNYIsiwWEBwCCcnC8ugWAEA2jHCysbhWPgQJRMTnAAIOU78HDcTkgKA9AKaYiaADMmgALH0ti9JjkTP6oKRflAAPRJqCcakuG0IJScbk3TmcITPB1Ol2JlO+uOBqAhqDh2gAq1QLN2lQYYhQfgqAJQAA+UA7-aDpubtuAci25E7KlIfagU-7AHYRy3x6dHc7iG6IB6vT7Y3PBzW56G57P++RggcMFHrjGlNVfpnbbmIPnC8WN8BiOXUz1q7WoaaKQfQNvQSZgqAkC8iUYDciUijWMCUAgkm9BQdAAAq4AQFoACOhCiJoABCzIYCYhCYaY2poMymG6PoOAqKIUrbAqA7avINQqJR1HoHRDHcVAxEuNKQQWA4xCiVAwC8EwEAuA4DD8JySgQIMq66JA7DYdBGCESRpguAA+qcnJ4qMDi6bhBFEcJzJcQYsnyaxABEaCuexrkAIQeSEDhkhS-FQCweAMIgEA4IMGFQBEEwxHEsiOUxhgaNogkGPARhkbAHCqTcxGcLmADyhIuDAeVKAVRWcqVhAVXA+WYEoAByEAkpUMiUJoDVNa17WdYk3XJqmTjpYAdgyACIMgBaDIAMQyANIMgAyDFAkqAIGRgAEvuNIUIKMUDjYALBqABAq5WVdVJWEr1VXNTAO3cF1PWnddt0IIQQ0jY4CR7TNC3LZQaAdhtW0sLtB3HQ5ehCc5CkWNKWj4KwnJMHghBRFoACKPRaH0mioxjl03AAsogXV9JQBwVsD6SANYMgB-2oA6gyAGYMjgQHhUCAOYMgDR6oAEFGAOnegCaDIA0QyABYMgCADIACr6ADnmi2AMbWdOAPIMgBWDJN41syLgC6DONgB7aoA-gnjYA+gyAIEMilQAlwDSNScBgPEzMEUNgwIPwCFKGA-CsNAl06u9YCnMAHCVAAtHAQh0qcLgxdZ+EGfZ6AuBYFFUSYNECclzGsT2kmcRDyixxyvGJ8F9Ep8JafsT+OfSlDOdKSpamDBYMWFbmLWcMAhEZSlZQ1TuTJbBHtmaFD4OMSole6qxymqdDupWThkd2RPalD5DclTzDMkr1XRQDbwddaQS44NzVdUsUXnevoIJHtyoZ-coIOV94QOdETno-KkXr9rw-xEDyvS9ORvY8K4AOnlAL+mgF4QD-ilD+rEYF1G3pvB+88a6QKvuveS5dQGzwIt-dBqD37ALXnArBkBI64IgVAkehDx4oM3ggBBY94EdR3vQCwBAwD7xkjhLA-VmG8S2D0TCEYi49HocwiMQCXLV0nrvdhnCYpPVGPVHKijuCYFgpyeqPUkhh24aohA6i4JaKgAAaTQTAFRvDOoWLQTA6UEDN5mKLiYzBjdOTN1bg-GAmgTGUEoHQ7esj8AcNsFw6CRMXotXMWoYwWwImGM0S1TQ-QdH124fEjRj8x5RKLsSTwupC5ZxSu6T0CBvTbVpAyBA-QXCWLanwlqlC8GYLEZURBPRXLcmEMAAAFq5YRRSVAtUwZhDpXShC9P6ZvDJRikm+nFJoG4SyhGpL3qE8OnAWrdEJElQZUAAAGAASQ4xI-j7LIjnXZw8DnHMQAwSoUAcl7NOfs1iUSmGVH+OhbhuMthNhKXuX0UTECpWQH0Bw2A8BEEaf8aKejcAEEIE865xIVEIvwAkm4kKCAJKRToh2TsXZuywOihJns5HrPhVC3FyKhKoq2Ni-AxUGCYSYHBCAhACb8GpBAVl7LCA0jpIyTQjTVkKPRcyvl3JKJoIBWUn0gqqkpIZRKllbLuS4qorvcVULJXqogLinOhTrlyvKYqxk-R8kWDMRgHlIBOAMFAbUhlSgABicB8CRSiIoCZPTTb8IIRgwBpi0F2odU64NTi9lHJOdss5mD8aYU2dswgviAnMPTW0xhyx2jar0W6j1XqfW9P9caoSpqFUIEqRa0mMcx7EjQaMzpxa+kSKgBA9iUMvm0HYRAHSOFCCMsIKQYakp+w9n7EeIMJ5TDuVck+WgMUuU8qlRyzCIq0H0owMu3l+rMU7tXZqzQMaWpnPxY7B0RLoAHr3Roz2MUAAiQc4DjgwGOtik65zTv7Kefs555xzkXHOVA-YACceboKYX4I1GVRcrC8EQEIe+aCY1PqEC+v4tyED3LRDAM5rEYDsVaSw3R0F3W8DiGWgw8HEPIaLjGu5Dy8PHKgzBqi+HpSEY+SRtJ0E0MvukLJLYqHn3ADORBrCjUOVGtlTuUpZqq1CuqdjHOtKDD8fHP2DTgm0T9lcgEcUnlx3imdRgHoOdLUWaWTcIRVrfTWfXVABzKmx49Ac4s5ZHmbMud1G5zzTn-PuYC95uzfmbNecc0FqLyyfMWDC5FwLiXwvBYSyFqzSXUuZYi9llLsX7MZZy9F5LRXMt5fi4VgrKWKvFYy2Vkr1WstVaa-V3LLg+g9BagMVhayD7pO5bu9lhqx7rtU2gmjwg7MAA1ZO7nlRUpT15fSgQsDlcbQg0HDODcRzeamUquVcpgybm9yNxEaWgxjuGE1oO07JTBN7BuZMc6xxJw14tScIII7GsBhoOfe5NzQBnKCk0zbwEH3be39sgJy-rq7CALPjK9+HSPNBI9JiYOdC6YrSBZkizd2ycrY7wjSzQ93pXmoQCKvxcLoKE6G48vHKwXBUeKXJwF5Oak5SbHFpUIKw2OqEYqFDxyXkEdOkmrZ8xCBwGZNxkcfxBgQ+ANZGQOOR3JPh1WYMYY0cY+p9AU25tLZZPp7k7Z+TmcqArfNpVoEcoG4tmATF9vLbE9AZoK3KT7YXudq7fXsQzYO7JU2ClvXoLO8d5k0bpvGfDZm-Jyt1blN2bCHHtnimbf5Lo3sj3y3dTSkwpvMIPQADk4zenF4GdczbeeI0gPD6757vFkkAAk5NN+C2EUmEmoCt49LB7PrO5vs6+w+rYxGs8msH+U8zY8LtQH+znazxZZsKcT-0YIbXDubwfd3xvJ8B8r4Twt2tGB9+T8P0tzBOfN5n-LVPn0PRydebn53zBYQb-g+CX2pXA7w8kGSZrjWGGMBKTMkoBCAbOh5E+EAA) -## 関数本体の実装 +## 解説 + +以降は実装の解説です。 + +### 関数本体の実装 型は後で付けるとして本体をまず実装します。 -実装方法は色々ありますが、以下のような実装をしておきます。 +実装方法は色々あり得ますが、以下のような実装をしておきます。 ```ts -function rangeArray( - start: number, - end: number, - step: number = 1, -): readonly number[] { - return Array.from(range(start, end, step)); // [...range(start, end, step)] でも ok +function rangeArray(start: number, end: number, step: number = 1): number[] { + return Array.from(range(start, end, step)); } function* range( @@ -64,9 +66,9 @@ for (const i of range(1, 5)) { // 4 ``` -## 型の実装 +### 型の実装 -`step = 1` （または省略されたとき）で `start` と `end` が型計算が再帰制限にひっかからない＆重くならない程度に十分小さい場合のみ型を詳細化したいので、以下のように関数をオーバーロードして、引数の型に応じて詳細化した型 `RangeList` と条件を満たさない場合の緩い型 `readonly number[]` を出し分けるようにします。 +結果配列が大きすぎる場合、型計算が重くなったりそもそも再帰制限にひっかかって計算できなかったりするので、 `start` と `end` が十分小さい場合のみ型を詳細化することにします。以下のように関数をオーバーロードして、引数の型に応じて return type を詳細化した型 `RangeList` にするか `number[]` にするかが決まるようにします。 ```ts type Uint8 = Index<256>; // 0 | 1 | 2 | ... | 255 @@ -74,26 +76,15 @@ type Uint8 = Index<256>; // 0 | 1 | 2 | ... | 255 function rangeArray( start: S, end: E, - step?: 1 + step?: 1, ): RangeList; -function rangeArray( - start: number, - end: number, - step?: Uint8 -): readonly number[]; - -function rangeArray( - start: number, - end: number, - step?: Uint8 = 1 -): readonly number[] { - return Array.from(range(start, end, step)); +function rangeArray(start: number, end: number, step?: number): number[]; ``` -`Index` 型ユーティリティも今回実装しますが、これに関してはべた書きでも良いかもしれません。 +`Uint8` 型はべた書きでも良いかもしれませんが、 `Index` という型ユーティリティを実装すれば `Index<256>` として実装できます。詳しくは[TypeScript 型ユーティリティ集](https://zenn.dev/noshiro_piko/articles/typescript-type-utilities)を参照してください。 -なお、 `start: S` と `end: E` には 1 個の非負整数ではなく union 型が渡される可能性もありますが、その場合には結果と厳密一致する型を生成しづらい（※）ため、その場合には `S` の最小値から `E` の最大値までの整数の union を要素とする長さ不定の配列型を返り値とするという要件もここで追加しておきます（※：一応 `S = 1 | 2`, `E = 3 | 4` に対して `[1, 2] | [1, 2, 3] | [2] | [2, 3]` という感じで全パターンの union 型を返すように定義できる可能性はありますが、 $|S| \times |E|$ のサイズの union になり型計算が重くなる上に見づらくなりあまり嬉しくもないのでこれは避けます。）。 +`start: S` や `end: E` には 1 個の非負整数ではなく `Uint8` の部分型の union 型（例： `1 | 2 | 3`）が渡される可能性もありますが、その場合には `S` の最小値から `E` の最大値までの整数の union を要素とする長さ不定の配列型を返り値とするという要件もここで追加しておきます[^union-arg]。 ```ts const s = 2 as 1 | 2 | 3; @@ -102,87 +93,157 @@ const result2: readonly (1 | 2 | 3 | 4 | 5 | 6)[] = rangeArray(s, e); console.log(result2); // [2, 3, 4, 5] ``` -これは以下のように引数にユーザー定義の数値の union 型の変数を渡す場合に、`rangeArray` の結果の型を不必要に広げないためです。 +[^union-arg]: 一応 `S = 1 | 2`, `E = 3 | 4` なら `[1, 2] | [1, 2, 3] | [2] | [2, 3]` という感じで全パターンの union 型を返すように定義できる可能性はありますが、 $|S| \times |E|$ のサイズの union になり型計算が重くなる上に結果の型も見づらくあまり嬉しくなさそうなので、これは実装しないことにします。 + +これは以下のように引数にユーザー定義の数値の union 型の変数を渡す場合にも対応するためです。 ```ts -type MonthEnum = Exclude, 0>; -type DateEnum = Exclude, 0>; +type MonthEnum = Exclude, 0>; // 1 | 2 | ... | 12 +type DateEnum = Exclude, 0>; // 1 | 2 | ... | 31 + +const getAllDatesOfMonth = (year: number, month: MonthEnum): DateEnum[] => + rangeArray( + 1, + (getLastDateNumberOfMonth(year, month) + 1) as 29 | 30 | 31 | 32, + ) satisfies DateEnum[]; const getLastDateNumberOfMonth = ( year: number, month: MonthEnum, ): 28 | 29 | 30 | 31 => new Date(year, month, 0).getDate() as 28 | 29 | 30 | 31; -const getAllDatesOfMonth = ( - year: number, - month: MonthEnum, -): readonly DateEnum[] => - rangeArray( - 1, - (getLastDateNumberOfMonth(year, month) + 1) as 29 | 30 | 31 | 32, - ).map( - (date: DateEnum) => new Date(year, month - 1, date).getDate() as DateEnum, - ); - console.log(getAllDatesOfMonth(2024, 2)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29] ``` 次節以降で `RangeList` 型を実装していきます。 -## `RangeList` の本体 +#### `RangeList` -`RangeList` の本体は以下のような実装になります。 +`RangeList` の本体は以下の実装になります。 ```ts type RangeList = - BoolOr< - BoolOr, IsNever>, // S, E のいずれかが 0 要素の union の場合 - BoolOr, IsUnion> // S, E のいずれかが >=2 要素の union の場合 - > extends true - ? readonly Exclude]>[] // union に対して Seq で型計算すると、結果が正しくないので、その回避のため - : Skip>; + // S, E のいずれかが 2 要素以上の union の場合 + BoolOr, IsUnion> extends true + ? Exclude]>[] // union に対して Seq で型計算すると、結果が正しくならないので、その回避のため + : ListSkip>; +``` + +ユニットテスト + +```ts +expectType, readonly [1, 2, 3, 4]>('='); +expectType, readonly [1]>('='); +expectType, readonly []>('='); +expectType, readonly (1 | 2)[]>('='); +expectType, readonly (1 | 2 | 3 | 4)[]>('='); +expectType, readonly (1 | 2 | 3 | 4 | 5 | 6)[]>( + '=', +); +expectType, readonly []>('='); ``` -- `Skip>` の部分は `S` と `E` がちょうど 1 要素の非負整数（0 以上 255 以下）の場合に対応しています - - 例： `RangeList<1, 5> = readonly [1, 2, 3, 4]` -- `readonly Exclude]>[]` の部分はそれ以外の場合に対応しています。 - - 例： `RangeList<1 | 2 | 3, 5 | 6 | 7> = readonly (1 | 2 | 3 | 4 | 5 | 6)[]` -- `IsNever` は `U` が 0 要素の union （ = `never`）であるとき `true`、そうでなければ `false` に評価される型を返します。 -- `IsUnion` は `U` が 2 要素以上の union 型であるとき `true`、そうでなければ `false` に評価される型を返します。 - - 例： `IsUnion<1 | 2> = true`, `IsUnion<1> = false`, -- `LEQ[U]` は `U` の最大値未満のすべての非負整数を含む union 型を返します。 - - 例： `LEQ[4 | 5 | 6] = 0 | 1 | 2 | 3 | 4 | 5` -- `Min` は `U` の最小の非負整数を返します。 - - 例： `Min<3 | 4 | 5> = 3` -- これらを組み合わせた `Exclude]>` という部分は、 `S = 1 | 2 | 3`, `E = 5 | 6 | 7` に対して `1 | 2 | 3 | 4 | 5 | 6` となる型です。 -- `Seq` は `N` までの非負整数の連番のタプル型を返します。 - - 例： `Seq<3> = readonly [0, 1, 2]` -- `Skip` はタプル型 `T` の先頭の `N` 要素を除いた型を返します。 - - 例： `Skip<2, [1, 2, 3]> = [3]` +`expectType` はここでは `expect("=")` が `A` と `B` は等しい型であることを確認する型レベルの assert 文を表しています。型ユニットテスト用ユーティリティ `expectType` の詳細については[TypeScript 型ユーティリティ集](https://zenn.dev/noshiro_piko/articles/typescript-type-utilities)を参照してください。 -以上のような型をそれぞれ実装できれば所望の型 `RangeList` が実装できることが確認できると思います。 -使っている型 `BoolOr`, `IsNever`, `IsUnion`, `LEQ`, `Min`, `Skip`, `Seq` という型の実装を次節以降それぞれ説明していきます。 +`ListSkip>` の部分は `S` と `E` がちょうど 1 要素の非負整数（0 以上 255 以下）の場合の型です。 -## `Min`, `BoolOr`, `IsNever`, `IsUnion` の実装 +`ListSkip` はタプル型 `T` の先頭 `N` 要素を除いた型を返す型です（例：`ListSkip<2, [1, 2, 3, 4, 5]>` = `[3, 4, 5]`）。 +`Seq` は整数 `N` までの連番配列を返す型です（例： `Seq<5>` = `[0, 1, 2, 3, 4]`。 +これらを組み合わせると `ListSkip>` とすることで `S` 以上 `E` 未満の整数の連番配列を作ることができます（例： `RangeList<1, 5> = [1, 2, 3, 4]`）。よって、 `ListSkip` と `Seq` を作ることができればここは解決します。 -`Min` の実装はこの記事で紹介しています。 -https://zenn.dev/noshiro_piko/articles/typescript-type-level-min +次に `S` または `E` が union 型の場合の判定ですが、これは `BoolOr` と `IsUnion` という型ユーティリティを実装することで実現できます。実装は [TypeScript 型ユーティリティ集](https://zenn.dev/noshiro_piko/articles/typescript-type-utilities)を参照してください。 +そしてそのときの型は、 union 型 `S` の中の最小値 `L` から union 型 `E` の中の最大値 - 1 = `U` までの union 型を要素とする配列 `(L | (L + 1) | ... | (U - 1) | U)[]` とします。これは `LEQ` という配列を作ることで `Exclude]>[]` として実装することができます。 +`LEQ[U]` は `U` の最大値未満のすべての非負整数を含む union 型を返すようにします（例： `LEQ[4 | 5 | 6] = 0 | 1 | 2 | 3 | 4 | 5`）。 `Min` は非負整数の union 型 `U` を受け取り、最小値を返す型です（例： `Min<3 | 4 | 5> = 3`）。`Min` の実装については[TypeScript の型ユーティリティ Min, Max の実装](https://zenn.dev/noshiro_piko/articles/typescript-type-level-min)という記事で解説しているのでそちらを参照してください。あとは `LEQ` を実装できれば OK です。 -`BoolOr` は型の論理和を取る関数で、[ここ](https://zenn.dev/link/comments/0c6cc10b5889f2)に実装を載せています。 +--- -`IsNever` は型が `never` かどうか判定する関数で、[ここ](https://zenn.dev/link/comments/914c745a18d71c)に実装を載せています。 +#### `ListSkip` の実装 + +以下の実装になります。 + + +```ts +type ListSkip = + ListSkipImpl; + +type ListSkipImpl< + N extends number, + T extends readonly unknown[], + R extends readonly unknown[], +> = T extends readonly [] + ? T + : R['length'] extends N + ? T + : ListSkipImpl, [Head, ...R]>; +``` -`IsUnion` は型が union 型かどうか判定する関数で、[ここ](https://zenn.dev/link/comments/d108fe1394e4f4)に実装を載せています。 +`Head` は `T` の先頭要素を取り出す型です。これは `infer` を使って以下で実装できます。 -## `LEQ` の実装 +```ts +type Head = T extends readonly [ + infer X, + ...(readonly unknown[]), +] + ? X + : D; +``` -## `Skip` の実装 +`Tail` は `T` の先頭要素を除いた残りの配列を返す型です。以下で実装できます。 -## `Seq` の実装 +```ts +type Tail = A extends readonly [] + ? readonly [] + : A extends readonly [unknown, ...infer R] + ? R + : A; +``` ---- +`ListSkipImpl` は、`T` を先頭要素 `H` と残りに分け、 `T` = `Tail`, `R` = `[Head, ...R]` と更新して再帰呼び出しし、 `R` の長さが `N` に到達した時点で `R['length'] extends N` という条件が満たされるので `T` が返される、という動作になっています。 -## 完成品 +``` +ListSkip<2, [1, 2, 3, 4, 5]> +-> ListSkipImpl<2, [1, 2, 3, 4, 5], []> +-> ListSkipImpl<2, [2, 3, 4, 5], [1]> +-> ListSkipImpl<2, [3, 4, 5], [2, 1]> +-> [3, 4, 5] +``` + +#### `Seq` の実装 + +```ts +type Seq = SeqImpl>; + +type SeqImpl = { + [i in keyof T]: i extends `${number}` ? ToNumber : never; +}; + +type ToNumber = S extends `${infer N extends number}` + ? N + : never; +``` + +`MakeTuple` は`N` 要素の `E` からなるタプルを返す型で、[TypeScript 型ユーティリティ集](https://zenn.dev/noshiro_piko/articles/typescript-type-utilities)で実装方法を解説しています。 +`Seq` は、長さ `N` の適当な配列を作り、 `keyof` でその key を取り出すことで連番配列を作っています。このとき `keyof` の結果は文字列リテラル型になってしまうのでこれを数値型にするために `ToNumber` を使っています。 + +#### `LEQ` の実装 + +```ts +type LEQ = { + [N in Uint8]: Index; +}; +// { +// 0: never; +// 1: 0; +// 2: 0 | 1; +// 3: 0 | 1 | 2; +// 4: 0 | 1 | 2 | 3; +// 5: 0 | 1 | 2 | 3 | 4; +// 6: 0 | 1 | 2 | 3 | 4 | 5; +// ... +// } +``` + +で実装できます。 -[TypeScript Playground](https://www.typescriptlang.org/play?#code/C4TwDgpgBAqglgO2ADigXigSQQEwgDwB4AmAVgDYA+AbgChaAzAVwQGNg4B7BKAJwEMEAcwgBBXgJCEAylALAIuAM6xEKADRQAonPwLlqpMkoAKWlChLg-XsABcUaevNzcDrc4tWIYAPwOARloASgcAJUERABk4KxlNLRp6ZjYObj5IsQl+EDMva1sHBCYAWwAjCF5PVxwi0oqql28-OvLKkIdeCH4cbgAbEChitt4AbQBdOkYWdi4eAWEsyTzLAvsh+srqxVqNkerm1ob0KCDQvm7ehAG9homoAG8XLuAmXh5xSQA6Bl5OEpMCxEJisNmAmh2mmawWCdAAvskZmkEAAqDKLFagwq3LYuHZHXH5HwE3gnM4OADiikq-GAnF4hGGDU0ADdOHAcJoWABrBCcADuCEojxcDHpUBMfQgwCgcBJJyxwGoqx8UGFAAYoL5ZVBCDUoA44GqasqjQBqDDQkUWCwgOAQPo4WV0CwIhG0VjcKwXJRMPrAAKdS79QajAKaYiaADMmgALOMTkCljkTOGoKRYVAAPRZqCcbker2cKVfPqcISAiC+-0BTM5qBhiPRuPjeiehDelQYYhQfgqAJQAA+UB7w6jdHb3ugGHIvZUpCHUFnw4A7BOvTKutXgMQgz0QxKB8PR1Ao4vY4uF8PyMF7hgk58U0oIbDCx3ixBS+XK9viHXc6MkannGmikK29BZmioCQLKJRgFKJSKNYyJQCiWb0NB0ARIsMRxLI8g7Co8BGAkuj6DgRFqMYJwAEKcMWADyDIuHRjEMpgSgAHIQCylQyJQmgcdxvEMokAnZrmTjaFAgB2DIAIgyAFoMgAxDIA0gyADIMUCaoAgZGAAS+MlQCwcyyYALBqABAqLH0X0TGEBxMAIHM-GCUodkOWJFj1lJOjycp6lqmgPa6fphnpDJZm0MKBEGMAvBMBALjal0+7XIMWj4KwfRMHghBRFoACKoxaOMmg5flACyiD8eMlD3PWwU8IA1gyAH-agDqDIAZgyOBAACOUCAOYMgDR6oAEFGAOnegCaDIA0QyABYMgCADIACr6ADnmamAMbWzWAPIMgBWDHJMk9VNgC6DDJgB7aoA-gkyYA+gyAIEMLgONI3JwGA8QdZ1hBiVMtCYVArFWQyohkYRUBlJZ3QIJoNE-QY-0foIwoYKMogJpFFENgw-B9EoECthY2qjDRcN6L9oxIyjaPxVABOo5dUDRbF5OUxAUxvUJPF8QAKlDDZMzj5EqKMCCM7wCbajTBok8jqN0+A0C2fZ3CEDArMAPqS3MmBwX0MtJLQkFogAAmolQIMjqHoW9CvOVLCDK-BMuaAA0qDCMwCcssnKMMAc3jPMiejWrC4T5O2-DKg8nygrEwzIlPWlGVZTANuUBFuNRTFcUYz7ZMWA4NPkx7lRizB5UIIQnF25RRjy-nFuq5xmgTOrxvlyrhAuEXAc4o0FhM8XFxJTcQcCggEzhScYd8Zx8ecxTSfE9nvDk0zowAORSsIwAABbz27BiccTc+L4oQir+v5Ny-XltVw26qaF8V-s7X4tQCVJxPBYiVXDcoxF4ghgoOMDjYHgRCj3hLnCWuACCF07kySorM-4EAYgwJmTB4IQEIKVfg3IIAIKQYQXugpNCj1vjBGB+A4GYKlIQDuLcX4Hhwf3KqJwFagOIfAxBUoK7kPVprKAOskB6wNmhV6d8GH-xISwiAbCXAUITgjKhyUDIIF5H3CY1RbYYHQSATgDAoBM0HhgDiAAxOA+AIA4CiHvVeuFgDsM7pnFO-spEqDURorRxM7HjwAAYABIHiQN4HCNx29OCcU2Aya2lAs683CSJLOwTgFYCUAYoxJizErwseQzuMie7yODrQqGLgfGdx3kvfea9+ap2gBnJOsSmaBOCTITunjvHBL8azfC9ioANMQAwSoUBm5tJ8X44mW905DF5rE1B6DSHIKZngiBwSy5oIwaI7ACh3giy+OMxZSDxHt2qA0ziAyOEom1rrVZfRDa0H1ohJQYB+CsGgMfBZkzlm8JRtaCmd8AAicAhBwBlBgTUw4jwjkXGeYcF5hxXiXIuFci5UDDgAJxTAsG9Jm-A4Cq0kePKwvBEBCFZpi36DSvk-OAHCLxnTukwD8d7B2RRRn0GRXfAxvA4gEoMNi3F+L6nkoQF00kVKvGovRew6l2paUjJEki95MFiW-OkNFE4RLvm-L8VKlF6LkEuHbuk4MsiaFKK1T0zusqZTDhNfK0kw554BHVPPRcNqXCs1GIajJoYiout1W-K+Xx2bVGfp60M3rplQCDe6m0XdX6BuvpfaNIbr5hptK6hsQaY0+tTcG0NfqI0HlGCmuNab80ZtjZmj13co0FrzZW4t1afUJv9WW5NNai0Vqbem9Ndbs2yNza2wtbbe39qrbWrNSbu0trHc2idfbB0To7SO6dU6e3zoHU2r24x36TAZboMA9IZRvQ2U8huhrpmGt6Vi6KuKs0AA0dUNv1QmaGXtWYcuEJ3IZNptTT0NQ4U9v157z0NdqS9X6oDMriKPTuFL+UAdgMa5VwALXQf3UshuwahWV3EnO6+GrCCjF9bAcSQbsOXs0DaygVVgOfvDXSyVtB3RvWkF1cBLcfHywY51NhgCIJHK4Sc-WZz+HGzY9so1zHgnVDZdIgNciFGCjvFAJDWCaF4LCazJ+iapOjCNJ-Rxmj2aGm5Y0kYoqtE1JGIQOAwpqM5xcHCKYnDuErL4+cwTN0wDCZ-QYHx4mb2Ruk9kg1Fgwg+eoVkxRrZVMuHVA4JmLpTgODltdW6HHNBofYZoEdAAJS4aX81hCqvCXDwWu2lM1OEBeRSD4bwRkXbUpXTgboETBRLd0PMIy81oormSZM5Poc19z4nqgjvC7ErLPQ0mUKk3ezQHyTjTy5RNhtzqLCQagMRlw3rKy3tC7J8YwRaBe0A+TD5VS0Wq2+gt3zd7WbnbaUN4md3hk3fHiOpT+aVt5eJmEANhAwhhOGV9sthBRBJCAA) +`Index` の実装は[TypeScript 型ユーティリティ集](https://zenn.dev/noshiro_piko/articles/typescript-type-utilities)を参照してください。 diff --git a/articles/typescript-type-level-min.md b/articles/typescript-type-level-min.md index 0fbc078182..590c6b6977 100644 --- a/articles/typescript-type-level-min.md +++ b/articles/typescript-type-level-min.md @@ -1,8 +1,8 @@ --- -title: 'TypeScript の型ユーティリティ Min, Max の実装' +title: '［型パズル］TypeScript の型ユーティリティ Min, Max の実装' emoji: '🐈' type: 'tech' # tech: 技術記事 / idea: アイデア -topics: ['typescript'] +topics: ['typescript', 'type-challenges'] published: true --- @@ -15,8 +15,8 @@ published: true type Min = /* TODO */; type Max = /* TODO */; -type R1 = Max<1 | 2 | 3>; // 3 -type R2 = Min<1 | 2 | 3>; // 1 +type T1 = Max<1 | 2 | 3>; // 3 +type T2 = Min<1 | 2 | 3>; // 1 ``` ## Min の実装 @@ -24,12 +24,12 @@ type R2 = Min<1 | 2 | 3>; // 1 `Min` は以下のコードで実装できます。 ```ts -type _MinImpl< +type Min = MinImpl; + +type MinImpl< N extends number, T extends readonly unknown[], -> = T['length'] extends N ? T['length'] : _MinImpl; - -export type Min = _MinImpl; +> = T['length'] extends N ? T['length'] : MinImpl; ``` （簡単な解説） @@ -39,9 +39,9 @@ TypeScript の型レベルプログラミングで非負整数に関する処理 ``` Min<1 | 2 | 3> --> _MinImpl<1 | 2 | 3, []> --> _MinImpl<1 | 2 | 3, [0]> // T["length"] (= 0) extends 1 | 2 | 3 は false なので再帰 --> 1 // T["length"] (= 1) extends 1 | 2 | 3 は true なので [0]["length"] = 1 を返す +-> MinImpl<1 | 2 | 3, []> +-> MinImpl<1 | 2 | 3, [0]> // T["length"] (= 0) extends 1 | 2 | 3 は false なので再帰 +-> 1 // T["length"] (= 1) extends 1 | 2 | 3 は true なので [0]["length"] = 1 を返す ``` ## Max の実装 @@ -50,12 +50,12 @@ Min<1 | 2 | 3> ```ts -type _MaxImpl +export type Max = MaxImpl; + +type MaxImpl = [N] extends [Partial["length"]] ? T["length"] - : _MaxImpl; - -export type Max = _MaxImpl; + : MaxImpl; ``` https://www.typescriptlang.org/play?#code/FAFwngDgpgBA+gWQIYA8CSBbCAbAPAORihRCgDsATAZxjIFcMAjKAJwBoYAVIk86mFlCQUA9mWxgYdMgGsyIgO5kA2gF0YAXhhqAfJu351xUpRrKACkhYgAlkjycdygETZyAcxAALZ6vUB+Lhc3Mk8fdQAueGR0LDx8DmUABg4AOnTOVR1gYGIIEWsYcGgYGIIeE356JlY9LURUTBwCHQBuHOLYACUoKjpsEH1lYBhS1FwknTYRsZQJmAAfGABGRZgAJimZsvW1gBY1gDYt0eSOFJgLpNVgj29fadHLazs8M8vz86zb0PvVYH+wCAA @@ -82,26 +82,26 @@ type Index = Partial<[0, 0, 0, 0]>['length']; ``` Max<1 | 2 | 3> --> _MaxImpl<1 | 2 | 3, []> --> _MaxImpl<1 | 2 | 3, [0]> // [1 | 2 | 3] extends [Partial<[]>["length"]] (= [0]) は false なので再帰 --> _MaxImpl<1 | 2 | 3, [0, 0]> // [1 | 2 | 3] extends [Partial<[0]>["length"]] (= [0 | 1]) は false なので再帰 --> _MaxImpl<1 | 2 | 3, [0, 0, 0]> // [1 | 2 | 3] extends [Partial<[0, 0]>["length"]] (= [0 | 1 | 2]) は false なので再帰 --> 3 // [1 | 2 | 3] extends [Partial<[0, 0, 0]>["length"]] (= [0 | 1 | 2 | 3]) は true なので [0, 0, 0]["length"] を返す +-> MaxImpl<1 | 2 | 3, []> +-> MaxImpl<1 | 2 | 3, [0]> // [1 | 2 | 3] extends [Partial<[]>["length"]] (= [0]) は false なので再帰 +-> MaxImpl<1 | 2 | 3, [0, 0]> // [1 | 2 | 3] extends [Partial<[0]>["length"]] (= [0 | 1]) は false なので再帰 +-> MaxImpl<1 | 2 | 3, [0, 0, 0]> // [1 | 2 | 3] extends [Partial<[0, 0]>["length"]] (= [0 | 1 | 2]) は false なので再帰 +-> 3 // [1 | 2 | 3] extends [Partial<[0, 0, 0]>["length"]] (= [0 | 1 | 2 | 3]) は true なので [0, 0, 0]["length"] を返す ``` 補足ですが、 `[N] extends [Partial["length"]]` のところは "union distribution" という挙動を回避するために TypeScript の型レベルプログラミングでたびたび用いられるテクニックが使われています。 -`extends` の両辺を配列にくるまず `N extends Partial["length"]` としてしまうと、 `N` （例では `1 | 2 | 3`）が分配されてそれぞれ評価されてしまいます。 `[N]` や `N[]` とすることでこの挙動を回避して union 型 `N` の全体と `Partial["length"]` を直接比較することができます。 +`extends` の両辺を配列にくるまず `N extends Partial["length"]` としてしまうと、 `N` （例では `1 | 2 | 3`）が分配されてそれぞれ評価されてしまいます。 `[N]` または `N[]` とすることでこの挙動を回避して union 型 `N` の全体と `Partial["length"]` をそのまま比較することができます。 逆に union 型の各要素についてループ処理を書きたいときには `N extends N ? ... : never` のようにして union distribution を使うこともあります。 ちなみに、先ほど載せたリンクの [StackOverflow の記事](https://stackoverflow.com/questions/62968955/how-to-implement-a-type-level-max-function-over-a-union-of-literals-in-typescri)では同じ投稿者が再帰上限にひっかからないための実装の改良も載せていますが、元実装 ```ts -type _MaxImpl = { +type MaxImpl = { b: T['length']; - r: _MaxImpl; + r: MaxImpl; }[[N] extends [Partial['length']] ? 'b' : 'r']; -export type Max = _MaxImpl; +export type Max = MaxImpl; type Result = Max<1 | 2 | 512>; // Type instantiation is excessively deep and possibly infinite. ts(2589) @@ -111,12 +111,12 @@ type Result = Max<1 | 2 | 512>; ```ts -type _MaxImpl +type MaxImpl = [N] extends [Partial["length"]] ? T["length"] - : _MaxImpl; + : MaxImpl; -export type Max = _MaxImpl; +export type Max = MaxImpl; type Result1 = Max<1 | 2 | 512>; // ok type Result2 = Max<1 | 2 | 1024>; // Type instantiation is excessively deep and possibly infinite. ts(2589) diff --git a/articles/typescript-type-utilities.md b/articles/typescript-type-utilities.md index 3443e053a2..079b5d17c6 100644 --- a/articles/typescript-type-utilities.md +++ b/articles/typescript-type-utilities.md @@ -1,13 +1,12 @@ --- -title: 'TypeScript 型ユーティリティ集' +title: '［型パズル］TypeScript 型ユーティリティ集' emoji: '🐈' type: 'tech' # tech: 技術記事 / idea: アイデア -topics: ['typescript'] +topics: ['typescript', 'type-challenges'] published: true --- -ほぼ私のライブラリ [ts-type-utils](https://github.com/noshiro-pf/mono/tree/main/packages/ts-type-utils) からの抜粋です（都合により TypeScript 標準ライブラリ（`lib.es5.d.ts` 等）に依存するかどうかでパッケージを分けています）。 -随時更新していきます。 +ほぼ私のライブラリ [ts-type-utils](https://github.com/noshiro-pf/mono/tree/main/packages/ts-type-utils) からの抜粋です。 --- @@ -15,17 +14,26 @@ published: true ```ts expectType<[1, 2, 3], [1, 2, 3]>('='); -expectType<[any], [number]>('<='); expectType('!='); expectType('!='); + +// @ts-expect-error +expectType<{ x: 1 } & { y: 2 }, { x: 1; y: 2 }>('='); + +expectType<{ x: 1 } & { y: 2 }, { x: 1; y: 2 }>('~='); + +expectType<{ x: 1 } & { y: 2 }, { x: 1; y: 2 }>('<='); + +expectType<{ x: 1 } & { y: 2 }, { x: 1; y: 2 }>('>='); ``` 型の等価性や部分型関係をチェックするユーティリティです。 -- `expectType("=")` は型 `A` と型 `B` が等価であるときに型エラーにならず、そうでないときに型エラーになります。 -- `expectType("!=")` は `"="` の逆です。 -- `expectType("<=")` は型 `A` が型 `B` の部分型であるとき型エラーにならず、部分型でないときに型エラーになります。 -- `expectType("~=")` は `A` が `B` の部分型かつ `B` が `A` の部分型であるときに型エラーにならず、そうでないときに型エラーになります。 `"="` の内部実装の `TypeEq` は例えば `{ x: 1 } & { y: 2 }` と `{ x: 1; y: 2 }` を区別してしまう程厳密なものなので、もう少し緩い等価判定を行いたい場合に用意しています。 +- `expectType("=")` ： 型 `A` と型 `B` が等しいかどうか +- `expectType("!=")` ： 型 `A` と型 `B` が等しくないかどうか +- `expectType("<=")` ： 型 `A` が型 `B` の部分型であるかどうか +- `expectType("~=")` ： `A` が `B` の部分型かつ `B` が `A` の部分型であるかどうか + - `"="` の内部実装の `TypeEq` は例えば `{ x: 1 } & { y: 2 }` と `{ x: 1; y: 2 }` を区別してしまう程厳密なものなので、もう少し緩い等価判定を行いたい場合に用意しています。 --- 実装 --- @@ -41,7 +49,7 @@ expectType('!='); * - `expectType("!>=")` passes if `B` doesn't extend `A`. * - `expectType("!=")` passes if `A` is not equal to `B`. */ -export const expectType = ( +const expectType = ( _relation: TypeEq extends true ? '<=' | '=' | '>=' | '~=' : @@ -121,11 +129,11 @@ type BoolAnd = `A` や `B` に `true`, `false` の他に `boolean` や `never`, `any` などが入ってくる可能性もあるため、 `TypeEq` で厳密一致するかどうかをチェックする実装にしています。 `true` か `false` になっていなければすべて `never` を返します。 :::details ソースコード（残りの実装） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/boolean.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/boolean.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/boolean.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/boolean.mts ::: ## `IsNever` @@ -149,7 +157,7 @@ type IsNever = [T] extends [never] ? true : false; ::: :::details テスト -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/is-never.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/is-never.mts ::: ## `IsUnion` @@ -164,22 +172,21 @@ expectType, true>('='); Type Challenges^[[Type Challenges (IsUnion)](https://github.com/type-challenges/type-challenges/blob/main/questions/01097-medium-isunion/README.md)]にも掲載されています。 ```ts -type IsUnion = _IsUnionImpl; +type IsUnion = IsUnionImpl; -/** @internal */ -type _IsUnionImpl = +type IsUnionImpl = IsNever extends true ? false : K extends K ? BoolNot> : never; ``` -まず与えられた型 `U` が `never` であれば `false` を返します。 +まず引数の型 `U` が `never` であれば `false` を返します。 次に union distribution[^1] を用いて `U` の各要素 `K` 取り出し、その `K` と `U` が等しければ、`U` は 1 要素の union ということになるので `false` を返し、そうでない場合は `true` を返す、という仕組みです。なお、最後の `never` に評価されることはありません（union distribution のイディオム）。 :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/is-union.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/is-union.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/is-union.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/is-union.mts ::: ## `ToNumber` @@ -189,7 +196,7 @@ expectType, 1000>('='); expectType, 8192>('='); ``` -数値の文字列型を数値型にします。 +数値の文字列型を数値型に変換します。 --- 実装 --- @@ -200,17 +207,17 @@ type ToNumber ``` :::message -注意： TypeScript 4.8 で実装された機能 に依存しているため、それ以前のバージョンでは tuple 型を経由して "length" プロパティを取り出す大掛かりな実装が必要になります。 +注意： TypeScript 4.8 で実装された機能に依存しているため、それ以前のバージョンでは tuple 型を経由して "length" プロパティを取り出す大掛かりな実装が必要になります。 @[card](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-8.html#improved-inference-for-infer-types-in-template-string-types) ::: :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/to-number.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/to-number.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/to-number.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/to-number.mts ::: ## `IsFixedLengthList` @@ -233,11 +240,11 @@ type IsFixedLengthList = 可変長配列（ `readonly number[]` など）の`"length"` の型が `number` 型であるのに対して、固定長の配列型（タプル型、 `[1, 2, 3]` など）の `"length"` の型が `number` 型ではなく定数の型（`3`など）になることを利用しています。 :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/is-fixed-length-list.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/is-fixed-length-list.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/is-fixed-length-list.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/is-fixed-length-list.mts ::: ## `IndexOfTuple` @@ -248,14 +255,14 @@ expectType, 0 | 1 | 2 | 3 | 4>('='); expectType, never>('='); ``` -タプル型のインデックスを返します。 +タプル型のインデックスの union を返します。 --- 実装 --- ```ts -type IndexOfTuple = _IndexOfTupleImpl; +type IndexOfTuple = IndexOfTupleImpl; -type _IndexOfTupleImpl = +type IndexOfTupleImpl = IsFixedLengthList extends true ? K extends keyof T ? K extends `${number}` @@ -269,11 +276,11 @@ type _IndexOfTupleImpl = `K extends '${number}'`は `K` が `ToNumber` の制約を満たしているというヒントを型システムに与えるために追加していますが、 `IndexOfTuple` からの入力では必ず真になるので実質何もしていない条件部です。 :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/index-of-tuple.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/index-of-tuple.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/index-of-tuple.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/index-of-tuple.mts ::: ## `MakeTuple` @@ -287,78 +294,68 @@ expectType, readonly [unknown, unknown, unknown]>('='); --- 実装 --- ```ts -type MakeTuple = _MakeTupleInternals.MakeTupleImpl< - Elm, - `${N}`, - [] ->; - -namespace _MakeTupleInternals { - type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; - - type Tail = T extends `${Digit}${infer U}` ? U : never; - - type First = T extends `${infer U}${Tail}` ? U : never; - - type DigitStr = `${Digit}`; - - type Tile< - T extends readonly unknown[], - N extends Digit | DigitStr | '10' | 10, - > = [ - readonly [], - readonly [...T], - readonly [...T, ...T], - readonly [...T, ...T, ...T], - readonly [...T, ...T, ...T, ...T], - readonly [...T, ...T, ...T, ...T, ...T], - readonly [...T, ...T, ...T, ...T, ...T, ...T], - readonly [...T, ...T, ...T, ...T, ...T, ...T, ...T], - readonly [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T], - readonly [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T], - readonly [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T], - ][N]; - - export type MakeTupleImpl< - T, - N extends string, - X extends readonly unknown[], - > = string extends N - ? never - : N extends '' - ? X - : First extends infer U - ? U extends DigitStr - ? MakeTupleImpl< - T, - Tail, - readonly [...Tile<[T], U>, ...Tile] - > - : never - : never; -} +type MakeTuple = MakeTupleImpl; + +type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + +type Tail = T extends `${Digit}${infer U}` ? U : never; + +type First = T extends `${infer U}${Tail}` ? U : never; + +type DigitStr = `${Digit}`; + +type Tile< + T extends readonly unknown[], + N extends Digit | DigitStr | '10' | 10, +> = [ + readonly [], + readonly [...T], + readonly [...T, ...T], + readonly [...T, ...T, ...T], + readonly [...T, ...T, ...T, ...T], + readonly [...T, ...T, ...T, ...T, ...T], + readonly [...T, ...T, ...T, ...T, ...T, ...T], + readonly [...T, ...T, ...T, ...T, ...T, ...T, ...T], + readonly [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T], + readonly [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T], + readonly [...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T, ...T], +][N]; + +type MakeTupleImpl< + T, + N extends string, + X extends readonly unknown[], +> = string extends N + ? never + : N extends '' + ? X + : First extends infer U + ? U extends DigitStr + ? MakeTupleImpl, readonly [...Tile<[T], U>, ...Tile]> + : never + : never; ``` かなり大がかりですが、巨大な tuple 型を作ろうとしても再帰制限にひっかからないようにするためこのように実装が工夫がされています。以下の記事で紹介されていたものをほぼそのまま利用しました（`ToNumber` の実装だけ TypeScript 4.8 の機能を使い効率化しています）。 参考： https://techracho.bpsinc.jp/yoshi/2020_09_04/97108 -以下の単純な再帰を行う実装でも小さな `N` に対しては同様に動きますが、 `N` が大きい場合に再帰回数の制限にひっかかってしまいます。 +以下の単純な再帰を行う実装でも小さな `N` に対しては同様に動きますが、 `N` が大きい場合にすぐ再帰回数の制限にひっかかってしまいます。 `MakeTupleNaive` の再帰回数は $O(N)$ なのに対し、 `MakeTuple` の再帰回数は $O(\log_{10} N)$ になります。 ```ts -type MakeTupleNaive = _MakeTupleNaiveImpl< +type MakeTupleNaive = MakeTupleNaiveImpl< N, Elm, readonly [] >; /** @internal */ -type _MakeTupleNaiveImpl = +type MakeTupleNaiveImpl = // T extends { length: Num } ? T - : _MakeTupleNaiveImpl; + : MakeTupleNaiveImpl; ``` ```ts @@ -367,11 +364,11 @@ expectType, MakeTuple<0, 1000>>('='); ``` :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/make-tuple.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/make-tuple.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/make-tuple.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/make-tuple.mts ::: ## `Index` @@ -381,7 +378,7 @@ expectType, 0 | 1 | 2>('='); expectType, 0 | 1 | 2 | 3 | 4>('='); ``` -与えられた整数未満の非負整数すべてからなる union 型を返します。 +整数引数 `N` 未満の非負整数すべてからなる union 型 `0 | 1 | ... | N - 1` を返します。 --- 実装 --- @@ -389,14 +386,14 @@ expectType, 0 | 1 | 2 | 3 | 4>('='); type Index = IndexOfTuple>; ``` -`MakeTuple` を利用して tuple を作った後 `IndexOfTuple` でその index を取り出す、という実装をしています。 +`MakeTuple` を利用して長さ `N` の tuple を作った後、 `IndexOfTuple` でその tuple の index を取り出す、という実装をしています。 :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/index-type.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/index-type.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/index-type.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/index-type.mts ::: ## `NegativeIndex` @@ -406,61 +403,56 @@ expectType, never>('='); expectType, -1 | -2 | -3 | -4 | -5>('='); ``` -与えられた整数以上の負整数すべて（`0` は除く）からなる union 型を返します。 +整数 `N` を受け取り、 `-N` 以上の負整数すべて（`0` は除く）からなる union 型 `-N | -N + 1 | ... | -1` を返します。 --- 実装 --- ```ts -type NegativeIndex = _NegativeIndexImpl.MapIdx< +type NegativeIndex = NegativeIndexImpl.MapIdx< RelaxedExclude, 0> >; -namespace _NegativeIndexImpl { - type ToNumberFromNegative = - S extends `${infer N extends number}` ? N : never; +type ToNumberFromNegative = + S extends `${infer N extends number}` ? N : never; - export type MapIdx = I extends I - ? ToNumberFromNegative<`-${I}`> - : never; -} +type MapIdx = I extends I + ? ToNumberFromNegative<`-${I}`> + : never; ``` `Index` と同様 tuple 型の index を取り出す実装を使っていますが、負数にするためにその index `I` を `-${I}` で文字列化して数値として取り出すという実装をしています。 :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/index-type.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/index-type.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/index-type.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/index-type.mts ::: ## Enum types -`Index` 型を実装したので以下の型も定義しておきます。 +`Index` 型を実装したので以下のような型が定義できます。 ```ts /** `0 | 1 | ... | 255` */ type Uint8 = Index<256>; -/** `0 | 1 | ... | 511` */ -type Uint9 = Index<512>; - -/** `0 | 1 | ... | 1023` */ -type Uint10 = Index<1024>; - /** `-128 | -127 | ... | -1 | 0 | 1 | ... | 126 | 127` */ type Int8 = Readonly | NegativeIndex<129>>; -/** `-256 | -255 | ... | -1 | 0 | 1 | ... | 254 | 255` */ -type Int9 = Readonly | NegativeIndex<257>>; +/** `1 | 2 | ... | 12` */ +type MonthEnum = Exclude, 0>; + +/** `0 | 1 | ... | 59` */ +type SecondsEnum = Sexagesimal; -/** `-512 | -511 | ... | -1 | 0 | 1 | ... | 510 | 511` */ -type Int10 = Readonly | NegativeIndex<513>>; +/** `0 | 1 | ... | 999` */ +type MillisecondsEnum = Index<1000>; ``` :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/enum.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/enum.d.mts ::: ## `UintRange` @@ -473,6 +465,9 @@ expectType, 0 | 1 | 2 | 3 | 4>('='); expectType, 2 | 3 | 4>('='); ``` +非負整数 `S`, `E` を受け取り、 `S` 以上 `E` 未満の整数全体の union を返します。 +`Index` と `Exclude` を組み合わせるだけで実装できます。 + --- 実装 --- ```ts @@ -482,14 +477,12 @@ type UintRange = Exclude< >; ``` -`Index` と `Exclude` を組み合わせるだけで実装できます。 - :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/uint-range.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/uint-range.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/uint-range.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/uint-range.mts ::: ## `Max`, `Min` @@ -509,15 +502,15 @@ expectType, 0>('='); 実装は[この記事](https://zenn.dev/noshiro_piko/articles/typescript-type-level-min)で解説しています。 :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/max.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/max.d.mts -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/min.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/min.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/max.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/max.mts -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/min.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/min.mts ::: ## `Seq` @@ -528,14 +521,14 @@ expectType, readonly []>('='); expectType, readonly [0, 1, 2, 3, 4]>('='); ``` -与えられた数値までの連番配列の型を返します。 +整数 `N` を受け取り、 0 から `N - 1` までの連番配列の型 `readonly [0, 1, ..., N - 1]` を返します。 --- 実装 --- ```ts -type Seq = _SeqImpl>; +type Seq = SeqImpl>; -type _SeqImpl = { +type SeqImpl = { readonly [i in keyof T]: i extends `${number}` ? ToNumber : never; }; ``` @@ -543,11 +536,11 @@ type _SeqImpl = { `MakeTuple` で長さ `N` の配列を作った後、その中身を Mapped Type で差し替えています。 :::details ソースコード -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/seq.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/src/seq.d.mts ::: :::details 使用例（ユニットテスト） -https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/seq.ts +https://github.com/noshiro-pf/mono/blob/develop/packages/ts-type-utils/test/seq.mts ::: --- diff --git a/articles/typescript-void-type.md b/articles/typescript-void-type.md index 451a2efaf1..803bf03dcf 100644 --- a/articles/typescript-void-type.md +++ b/articles/typescript-void-type.md @@ -117,7 +117,7 @@ if (!!maybeUser) { このメソッドは、 `Promise` 型を戻り値とするメソッド `signinPopupCallback`, `signinSilentCallback` と `Promise` 型を戻り値とする `signinRedirectCallback` が中で呼び分けられる内部実装になっており、これをそのまま `Promise` という戻り値型にしているようでした。 ```ts -export class UserManager { +class UserManager { // ... public async signinCallback( From e73a4edd9adb801021215a3e6d06753842789c7a Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Tue, 11 Feb 2025 20:51:06 +0900 Subject: [PATCH 02/25] create playground implement-react-hooks --- .../others/implement-react-hooks/README.md | 1 + .../configs/rollup.config.ts | 11 ++++ .../configs/tsconfig.build.json | 13 +++++ .../configs/tsconfig.test.json | 7 +++ .../configs/vitest.config.ts | 18 ++++++ .../implement-react-hooks/eslint.config.js | 43 ++++++++++++++ .../others/implement-react-hooks/package.json | 54 ++++++++++++++++++ .../implement-react-hooks/src/index.mts | 56 +++++++++++++++++++ .../implement-react-hooks/tsconfig.json | 8 +++ 9 files changed, 211 insertions(+) create mode 100644 packages/others/implement-react-hooks/README.md create mode 100644 packages/others/implement-react-hooks/configs/rollup.config.ts create mode 100644 packages/others/implement-react-hooks/configs/tsconfig.build.json create mode 100644 packages/others/implement-react-hooks/configs/tsconfig.test.json create mode 100644 packages/others/implement-react-hooks/configs/vitest.config.ts create mode 100644 packages/others/implement-react-hooks/eslint.config.js create mode 100644 packages/others/implement-react-hooks/package.json create mode 100644 packages/others/implement-react-hooks/src/index.mts create mode 100644 packages/others/implement-react-hooks/tsconfig.json diff --git a/packages/others/implement-react-hooks/README.md b/packages/others/implement-react-hooks/README.md new file mode 100644 index 0000000000..f44347bf8f --- /dev/null +++ b/packages/others/implement-react-hooks/README.md @@ -0,0 +1 @@ +https://medium.com/swlh/learn-by-implementing-reacts-usestate-and-useeffect-a-simplified-overview-ea8126705a88 diff --git a/packages/others/implement-react-hooks/configs/rollup.config.ts b/packages/others/implement-react-hooks/configs/rollup.config.ts new file mode 100644 index 0000000000..8973671827 --- /dev/null +++ b/packages/others/implement-react-hooks/configs/rollup.config.ts @@ -0,0 +1,11 @@ +/* eslint-disable import/no-default-export */ +/* eslint-disable import/no-internal-modules */ + +import { toThisDir } from '@noshiro/mono-utils'; +import { defineRollupConfig } from '../../../../configs/define-rollup-config.mjs'; +import tsconfig from './tsconfig.build.json' with { type: 'json' }; + +export default defineRollupConfig({ + configDir: toThisDir(import.meta.url), + outDirRelative: tsconfig.compilerOptions.outDir, +}); diff --git a/packages/others/implement-react-hooks/configs/tsconfig.build.json b/packages/others/implement-react-hooks/configs/tsconfig.build.json new file mode 100644 index 0000000000..e247e714de --- /dev/null +++ b/packages/others/implement-react-hooks/configs/tsconfig.build.json @@ -0,0 +1,13 @@ +{ + "extends": [ + "../../../../configs/tsconfig/tsconfig.lib.build.json", + "../../../../configs/tsconfig/tsconfig.vite.json" + ], + "compilerOptions": { + "outDir": "../esm", + "declarationDir": "../esm", + "rootDir": "../src" + }, + "include": ["../src"], + "exclude": ["../src/**/*.test.mts"] +} diff --git a/packages/others/implement-react-hooks/configs/tsconfig.test.json b/packages/others/implement-react-hooks/configs/tsconfig.test.json new file mode 100644 index 0000000000..4a6232c488 --- /dev/null +++ b/packages/others/implement-react-hooks/configs/tsconfig.test.json @@ -0,0 +1,7 @@ +{ + "extends": [ + "../../../../configs/tsconfig/tsconfig.test.json", + "../../../../configs/tsconfig/tsconfig.vite.json" + ], + "include": ["../src"] +} diff --git a/packages/others/implement-react-hooks/configs/vitest.config.ts b/packages/others/implement-react-hooks/configs/vitest.config.ts new file mode 100644 index 0000000000..56e547d576 --- /dev/null +++ b/packages/others/implement-react-hooks/configs/vitest.config.ts @@ -0,0 +1,18 @@ +import { toThisDir } from '@noshiro/mono-utils'; +import * as path from 'node:path'; +import { defineConfig } from 'vitest/config'; + +const thisDir: string = toThisDir(import.meta.url); + +// https://github.com/vitest-dev/vitest/blob/v1.5.0/test/import-meta/vite.config.ts +export default defineConfig({ + test: { + globals: true, + dir: path.resolve(thisDir, '../src'), + includeSource: [path.resolve(thisDir, '../src/**/*.mts')], + typecheck: { + tsconfig: path.resolve(thisDir, 'tsconfig.test.json'), + }, + passWithNoTests: true, + }, +}); diff --git a/packages/others/implement-react-hooks/eslint.config.js b/packages/others/implement-react-hooks/eslint.config.js new file mode 100644 index 0000000000..a16615ca07 --- /dev/null +++ b/packages/others/implement-react-hooks/eslint.config.js @@ -0,0 +1,43 @@ +/** @typedef {import('@noshiro/eslint-configs').FlatConfig} FlatConfig */ + +import { + eslintFlatConfigForTypeScript, + eslintFlatConfigForVitest, + genEsLintRestrictedImportsDefFromDevDependencies, +} from '@noshiro/eslint-configs'; +import { toThisDir } from '@noshiro/mono-utils'; +import * as path from 'node:path'; +import packageJson from './package.json' with { type: 'json' }; + +const thisDir = toThisDir(import.meta.url); + +/** @returns {Promise} */ +const defineConfig = async () => { + const restrictedImports = + await genEsLintRestrictedImportsDefFromDevDependencies( + packageJson.devDependencies, + ); + + /** @type {readonly FlatConfig[]} */ + const configs = [ + ...eslintFlatConfigForTypeScript({ + tsconfigRootDir: thisDir, + tsconfigFileName: './tsconfig.json', + packageDirs: [path.resolve(thisDir, '../../..'), thisDir], + }), + eslintFlatConfigForVitest(['src/**/*']), + + { + rules: { + '@typescript-eslint/no-restricted-imports': [ + 'error', + ...restrictedImports, + ], + }, + }, + ]; + + return configs; +}; + +export default defineConfig(); diff --git a/packages/others/implement-react-hooks/package.json b/packages/others/implement-react-hooks/package.json new file mode 100644 index 0000000000..e09fbfd545 --- /dev/null +++ b/packages/others/implement-react-hooks/package.json @@ -0,0 +1,54 @@ +{ + "name": "@noshiro/implement-react-hooks", + "version": "1.0.0", + "private": false, + "license": "MIT", + "author": "noshiro-pf ", + "sideEffects": true, + "type": "module", + "scripts": { + "build": "wireit", + "clean": "run-p clean:**", + "clean:build": "rimraf esm", + "clean:wireit": "rimraf .wireit/**", + "fmt": "yarn zz:prettier .", + "lint": "yarn zz:eslint:src", + "lint:fix": "yarn zz:eslint:src --fix", + "start": "wireit", + "test": "yarn zz:vitest run", + "testw": "yarn zz:vitest watch", + "tsc": "yarn type-check", + "tscw": "tsc --noEmit --watch", + "type-check": "tsc --noEmit", + "zz:eslint": "ESLINT_USE_FLAT_CONFIG=true TIMING=1 eslint", + "zz:eslint:print-config": "yarn zz:eslint --print-config src/index.mts", + "zz:eslint:src": "yarn zz:eslint --config eslint.config.js './src/**/*'", + "zz:prettier": "prettier --cache --cache-strategy content --ignore-path ../../../.prettierignore --write", + "zz:vitest": "vitest --config ./configs/vitest.config.ts" + }, + "dependencies": { + "@noshiro/ts-utils": "*" + }, + "devDependencies": { + "@noshiro/eslint-configs": "*", + "@noshiro/mono-utils": "*", + "@noshiro/ts-type-utils": "*" + }, + "wireit": { + "pre-build": { + "command": "run-s clean:build type-check" + }, + "build": { + "dependencies": [ + "pre-build" + ], + "command": "rollup --config ./configs/rollup.config.ts --configPlugin typescript --configImportAttributesKey with" + }, + "start": { + "dependencies": [ + "build" + ], + "command": "node ./esm/index.mjs" + } + } +} diff --git a/packages/others/implement-react-hooks/src/index.mts b/packages/others/implement-react-hooks/src/index.mts new file mode 100644 index 0000000000..e54104baba --- /dev/null +++ b/packages/others/implement-react-hooks/src/index.mts @@ -0,0 +1,56 @@ +function outerFunction() { + let mut_counter = 0; // defined outside inner function + return function innerFunction() { + mut_counter += 1; // counter accessible inside inner function (private variable) + return mut_counter; + }; +} + +const getInnerFunction = outerFunction(); + +console.log(getInnerFunction()); // prints 1 +console.log(getInnerFunction()); // prints 2 +console.log(getInnerFunction()); // prints 3 +console.log(getInnerFunction()); // prints 4 + +type ComponentInstance = Readonly<{ + render: () => void; +}>; + +type ComponentDef = () => ComponentInstance; + +const React = (() => { + const mut_global: { + component: ComponentDef | undefined; + instance: ComponentInstance | undefined; + } = { + component: undefined, + instance: undefined, + }; // define a global variable where we store information about the component + + let mut_index = 0; // index to keep track of the component's state + + console.log({ mut_index }); + + const render = (component: ComponentDef): unknown => { + mut_global.component = component; + const instance = component(); // get the instance of the component + mut_index = 0; + instance.render(); + mut_global.instance = instance; // store the component's instance for any future calls of the component's functions + return mut_global; // return the global variable + }; + + const useState = (initialState: T): T => + // implement useState + initialState; + + const useEffect = (cb: () => void, deps: readonly unknown[]): void => { + // implement useEffect + console.log(cb, deps); + }; + + return { render, useState, useEffect }; +})(); + +export { React }; diff --git a/packages/others/implement-react-hooks/tsconfig.json b/packages/others/implement-react-hooks/tsconfig.json new file mode 100644 index 0000000000..d8fd7d0994 --- /dev/null +++ b/packages/others/implement-react-hooks/tsconfig.json @@ -0,0 +1,8 @@ +{ + "extends": [ + "../../../configs/tsconfig/tsconfig.lib.type-check.json", + "../../../configs/tsconfig/tsconfig.dom", + "../../../configs/tsconfig/tsconfig.vite.json" + ], + "include": ["./src", "./configs"] +} From 840b9c0f0360950580266ac038d805c345f7a482 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Mon, 10 Oct 2022 17:51:21 +0900 Subject: [PATCH 03/25] -------- --- docs/---------- | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/---------- diff --git a/docs/---------- b/docs/---------- new file mode 100644 index 0000000000..e69de29bb2 From 02a9a31605e051936ed817421f771a6371f222bc Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Mon, 9 Jan 2023 16:12:02 +0900 Subject: [PATCH 04/25] -------- --- docs/----------- | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/----------- diff --git a/docs/----------- b/docs/----------- new file mode 100644 index 0000000000..e69de29bb2 From 002472fcd3a1f11989a72339476b36358f1811d5 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sun, 9 Oct 2022 18:28:51 +0900 Subject: [PATCH 05/25] -------- --- docs/------ | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/------ diff --git a/docs/------ b/docs/------ new file mode 100644 index 0000000000..e69de29bb2 From 21493c89b367cebf2c0cac84e1ff5df6c39e2d28 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Fri, 31 Jan 2025 06:35:35 +0900 Subject: [PATCH 06/25] feat: [event-schedule-app] sort event list of user by create time --- .../src/v9/types/record/event-list-item.mts | 2 ++ .../v9/types/record/event-list-item.test.mts | 4 ++++ .../src/fetch-event-list-of-user.mts | 22 ++++++++++++++----- 3 files changed, 23 insertions(+), 5 deletions(-) diff --git a/packages/apps/event-schedule-app-shared/src/v9/types/record/event-list-item.mts b/packages/apps/event-schedule-app-shared/src/v9/types/record/event-list-item.mts index 0104f95b62..b0012e02d1 100644 --- a/packages/apps/event-schedule-app-shared/src/v9/types/record/event-list-item.mts +++ b/packages/apps/event-schedule-app-shared/src/v9/types/record/event-list-item.mts @@ -7,7 +7,9 @@ export const EventListItem = t.record({ eventScheduleMetadata: t.record({ id: t.string(''), createdAt: t.string(''), + createdAtMillis: t.number(0), updatedAt: t.string(''), + updatedAtMillis: t.number(0), }), answers: t.array(Answer), diff --git a/packages/apps/event-schedule-app-shared/src/v9/types/record/event-list-item.test.mts b/packages/apps/event-schedule-app-shared/src/v9/types/record/event-list-item.test.mts index ab66a47e2d..b5076e7e5b 100644 --- a/packages/apps/event-schedule-app-shared/src/v9/types/record/event-list-item.test.mts +++ b/packages/apps/event-schedule-app-shared/src/v9/types/record/event-list-item.test.mts @@ -11,7 +11,9 @@ describe('EventListItem', () => { eventScheduleMetadata: Readonly<{ id: string; createdAt: string; + createdAtMillis: number; updatedAt: string; + updatedAtMillis: number; }>; answers: readonly Answer[]; @@ -27,7 +29,9 @@ describe('EventListItem', () => { eventScheduleMetadata: { id: '', createdAt: '', + createdAtMillis: 0, updatedAt: '', + updatedAtMillis: 0, }, answers: [], answersMetadata: { diff --git a/packages/apps/event-schedule-app/functions/src/fetch-event-list-of-user.mts b/packages/apps/event-schedule-app/functions/src/fetch-event-list-of-user.mts index 477d2893b6..f596848f57 100644 --- a/packages/apps/event-schedule-app/functions/src/fetch-event-list-of-user.mts +++ b/packages/apps/event-schedule-app/functions/src/fetch-event-list-of-user.mts @@ -51,7 +51,9 @@ export const fetchEventListOfUserImpl = async ( eventScheduleMetadata: { id: d.id, createdAt: d.createTime.toDate().toISOString(), + createdAtMillis: d.createTime.toMillis(), updatedAt: d.updateTime.toDate().toISOString(), + updatedAtMillis: d.updateTime.toMillis(), }, })); @@ -126,6 +128,7 @@ export const fetchEventListOfUserImpl = async ( .filter(({ eventScheduleMetadata }) => { const ans = answersOfEventMap.get(eventScheduleMetadata.id); + // 自分が回答しているかどうか return ans?.answers.some(({ user }) => user.id === uid) ?? false; }) .map(({ eventSchedule, eventScheduleMetadata }): EventListItem => { @@ -139,9 +142,18 @@ export const fetchEventListOfUserImpl = async ( }; }); - return eventListItems.filter( - ({ eventSchedule, answers }) => - eventSchedule.author.id === uid || - answers.some(({ user }) => user.id === uid), - ); + return eventListItems + .filter( + ({ eventSchedule, answers }) => + eventSchedule.author.id === uid || + answers.some(({ user }) => user.id === uid), + ) + .toSorted( + (a, b) => + // 作成日時降順でソート + -( + a.eventScheduleMetadata.createdAtMillis - + b.eventScheduleMetadata.createdAtMillis + ), + ); }; From c9880550129097bdb493d1a20fe9a94fece78310 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sun, 9 Oct 2022 19:09:52 +0900 Subject: [PATCH 07/25] -------- --- docs/------- | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/------- diff --git a/docs/------- b/docs/------- new file mode 100644 index 0000000000..e69de29bb2 From ea1a1be6ab9dd9f71abf4debd4512e1fc9220541 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sun, 9 Oct 2022 19:09:57 +0900 Subject: [PATCH 08/25] -------- --- docs/-------- | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/-------- diff --git a/docs/-------- b/docs/-------- new file mode 100644 index 0000000000..e69de29bb2 From 57261421fc4945642c23667c0c8116e77701c5a3 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Thu, 6 Feb 2025 14:16:42 +0900 Subject: [PATCH 09/25] improve branded type implementation [WIP] --- packages/ts-type-utils/src/brand.d.mts | 34 ++--- .../ts-type-utils/src/branded-types.d.mts | 128 ++++++++++++++---- packages/ts-type-utils/src/std.d.mts | 2 +- packages/ts-type-utils/test/brand.mts | 6 +- .../src/num/branded-types/finite-number.mts | 6 + 5 files changed, 129 insertions(+), 47 deletions(-) diff --git a/packages/ts-type-utils/src/brand.d.mts b/packages/ts-type-utils/src/brand.d.mts index 4c769b8f8f..141f07f733 100644 --- a/packages/ts-type-utils/src/brand.d.mts +++ b/packages/ts-type-utils/src/brand.d.mts @@ -1,21 +1,21 @@ type UnknownBrand = Brand; +declare const brandKey: unique symbol; + /** @internal */ declare namespace TSTypeUtilsInternals { - // const brand_: unique symbol; - /** * `ts-type-utils` 外で作られた branded type と競合しないように型を区別する。 * - * MEMO: [gcanti/io-ts](https://github.com/gcanti/io-ts) では unique symbol - * を使っているが 型ライブラリとして独立できるようにするために ts-type-utils では使用していない。 - * * @internal */ type BrandEncapsulated = B & Readonly<{ - 'TSTypeUtilsInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown; + [brandKey]: unknown; }>; + // Readonly<{ + // 'TSTypeUtilsInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown; + // }>; type ExtractTrueKeys = ExtractBooleanKeysImpl< B, @@ -42,7 +42,7 @@ declare namespace TSTypeUtilsInternals { > = K extends K ? (TypeEq extends true ? K : never) : never; } -type Brand = T & +type Brand = T & TSTypeUtilsInternals.BrandEncapsulated<{ readonly [key in FalseKeys | TrueKeys]: key extends TrueKeys ? true : false; }>; @@ -66,35 +66,35 @@ type GetBrandKeysPart = Pick>; type GetBrandValuePart = B extends Brand< infer T, - UnwrapBrandTrueKeys & string, - UnwrapBrandFalseKeys & string + UnwrapBrandTrueKeys & symbol, + UnwrapBrandFalseKeys & symbol > ? T : never; type ExtendBrand< B extends UnknownBrand, - T extends string, - F extends string = never, + T extends symbol, + F extends symbol = never, > = IsNever extends true // T and F shouldn't have intersection ? Brand< GetBrandValuePart, - T | (UnwrapBrandTrueKeys & string), - F | (UnwrapBrandFalseKeys & string) + T | (UnwrapBrandTrueKeys & symbol), + F | (UnwrapBrandFalseKeys & symbol) > : never; type ChangeBaseBrand = Brand< T, - UnwrapBrandTrueKeys & string, - UnwrapBrandFalseKeys & string + UnwrapBrandTrueKeys & symbol, + UnwrapBrandFalseKeys & symbol >; type IntersectBrand = Brand< GetBrandValuePart & GetBrandValuePart, - string & (UnwrapBrandTrueKeys | UnwrapBrandTrueKeys), - string & (UnwrapBrandFalseKeys | UnwrapBrandFalseKeys) + symbol & (UnwrapBrandTrueKeys | UnwrapBrandTrueKeys), + symbol & (UnwrapBrandFalseKeys | UnwrapBrandFalseKeys) >; /** ある key が true | false になる場合、その key を削除する */ diff --git a/packages/ts-type-utils/src/branded-types.d.mts b/packages/ts-type-utils/src/branded-types.d.mts index 963adae3b8..fd9898e04d 100644 --- a/packages/ts-type-utils/src/branded-types.d.mts +++ b/packages/ts-type-utils/src/branded-types.d.mts @@ -1,6 +1,48 @@ +/* eslint-disable @typescript-eslint/no-unused-vars */ + +declare const __brandKeyLt2_15__: unique symbol; +declare const __brandKeyLt2_16__: unique symbol; +declare const __brandKeyLt2_31__: unique symbol; +declare const __brandKeyLt2_32__: unique symbol; +declare const __brandKeyGtMinus2_16__: unique symbol; +declare const __brandKeyGtMinus2_32__: unique symbol; +declare const __brandKeyGeMinus2_15__: unique symbol; +declare const __brandKeyGeMinus2_31__: unique symbol; +declare const __brandKeyGe0__: unique symbol; +declare const __brandKeyNe0__: unique symbol; +declare const __brandKeyFinite__: unique symbol; +declare const __brandKeyFloat32__: unique symbol; +declare const __brandKeyFloat64__: unique symbol; +declare const __brandKeyInt__: unique symbol; +declare const __brandKeyNaNValue__: unique symbol; +declare const __brandKeySafeInt__: unique symbol; +declare const __brandKeyBigInt64__: unique symbol; +declare const __brandKeyBigUint64__: unique symbol; + +type NumberBrandKeys__ = Readonly<{ + '< 2^15': typeof __brandKeyLt2_15__; + '< 2^16': typeof __brandKeyLt2_16__; + '< 2^31': typeof __brandKeyLt2_31__; + '< 2^32': typeof __brandKeyLt2_32__; + '> -2^16': typeof __brandKeyGtMinus2_16__; + '> -2^32': typeof __brandKeyGtMinus2_32__; + '>= -2^15': typeof __brandKeyGeMinus2_15__; + '>= -2^31': typeof __brandKeyGeMinus2_31__; + '>=0': typeof __brandKeyGe0__; + '!=0': typeof __brandKeyNe0__; + Finite: typeof __brandKeyFinite__; + Float32: typeof __brandKeyFloat32__; + Float64: typeof __brandKeyFloat64__; + Int: typeof __brandKeyInt__; + NaNValue: typeof __brandKeyNaNValue__; + SafeInt: typeof __brandKeySafeInt__; + BigInt64: typeof __brandKeyBigInt64__; + BigUint64: typeof __brandKeyBigUint64__; +}>; + /** @internal */ declare namespace TSTypeUtilsInternals { - type IntRangeKeys = + type IntRangeStringKeys = | '< 2^15' | '< 2^16' | '< 2^31' @@ -11,8 +53,8 @@ declare namespace TSTypeUtilsInternals { | '>= -2^31' | '>=0'; - type Keys_ = - | IntRangeKeys + type StringKeys_ = + | IntRangeStringKeys | '!=0' | 'Finite' | 'Float32' @@ -21,6 +63,10 @@ declare namespace TSTypeUtilsInternals { | 'NaNValue' | 'SafeInt'; + type IntRangeKeys = NumberBrandKeys__[IntRangeStringKeys]; + + type Keys_ = NumberBrandKeys__[StringKeys_]; + type BrandedNumberBaseType = Brand; type ExtendNumberBrand< @@ -29,8 +75,18 @@ declare namespace TSTypeUtilsInternals { F extends RelaxedExclude> = never, > = Brand< GetBrandValuePart, - T | (UnwrapBrandTrueKeys & string), - F | (UnwrapBrandFalseKeys & string) + T | (UnwrapBrandTrueKeys & symbol), + F | (UnwrapBrandFalseKeys & symbol) + >; + + type ExtendNumberBrandByStringKey< + B extends BrandedNumberBaseType, + T extends RelaxedExclude>, + F extends RelaxedExclude> = never, + > = Brand< + GetBrandValuePart, + NumberBrandKeys__[T] | (UnwrapBrandTrueKeys & symbol), + NumberBrandKeys__[F] | (UnwrapBrandFalseKeys & symbol) >; type SmallIntIndexMax = 40; @@ -45,14 +101,14 @@ declare namespace TSTypeUtilsInternals { } /** Numeric brand type for `NaN` */ -type NaNType = TSTypeUtilsInternals.ExtendNumberBrand< +type NaNType = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< TSTypeUtilsInternals.BrandedNumberBaseType, '!=0' | 'NaNValue', - TSTypeUtilsInternals.IntRangeKeys | '>=0' | 'Finite' | 'Int' | 'SafeInt' + TSTypeUtilsInternals.IntRangeStringKeys | '>=0' | 'Finite' | 'Int' | 'SafeInt' >; /** Numeric brand type for numbers except `NaN` */ -type ValidNumber = TSTypeUtilsInternals.ExtendNumberBrand< +type ValidNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< TSTypeUtilsInternals.BrandedNumberBaseType, never, 'NaNValue' @@ -61,21 +117,24 @@ type ValidNumber = TSTypeUtilsInternals.ExtendNumberBrand< /** Numeric brand type for value after checking with `Number.isFinite(x)` */ type FiniteNumber = TSTypeUtilsInternals.ExtendNumberBrand< ValidNumber, - 'Finite' + NumberBrandKeys__['Finite'] >; /** Numeric brand type for `Infinity` */ -type InfiniteNumber = TSTypeUtilsInternals.ExtendNumberBrand< +type InfiniteNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< ValidNumber, '!=0', 'Finite' | 'Int' | 'SafeInt' >; /** Numeric brand type for value after checking with `x != 0` */ -type NonZeroNumber = TSTypeUtilsInternals.ExtendNumberBrand; +type NonZeroNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< + ValidNumber, + '!=0' +>; /** Numeric brand type for value after checking with `x >= 0` */ -type NonNegativeNumber = TSTypeUtilsInternals.ExtendNumberBrand< +type NonNegativeNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< ValidNumber, '> -2^16' | '> -2^32' | '>= -2^15' | '>= -2^31' | '>=0' >; @@ -84,21 +143,21 @@ type NonNegativeNumber = TSTypeUtilsInternals.ExtendNumberBrand< type PositiveNumber = IntersectBrand; /** Numeric brand type for value after checking with `x < 0` */ -type NegativeNumber = TSTypeUtilsInternals.ExtendNumberBrand< +type NegativeNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< NonZeroNumber, '< 2^15' | '< 2^16' | '< 2^31' | '< 2^32', '>=0' >; /** Numeric brand type for `Number.POSITIVE_INFINITY` */ -type POSITIVE_INFINITY = TSTypeUtilsInternals.ExtendNumberBrand< +type POSITIVE_INFINITY = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< IntersectBrand, never, '< 2^15' | '< 2^16' | '< 2^31' | '< 2^32' >; /** Numeric brand type for `Number.NEGATIVE_INFINITY` */ -type NEGATIVE_INFINITY = TSTypeUtilsInternals.ExtendNumberBrand< +type NEGATIVE_INFINITY = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< IntersectBrand, never, '> -2^16' | '> -2^32' | '>= -2^15' | '>= -2^31' @@ -131,7 +190,10 @@ type NegativeFiniteNumber = IntersectBrand; // integer types /** Numeric brand type for value after checking with `Number.isInteger(x)` */ -type Int = TSTypeUtilsInternals.ExtendNumberBrand; +type Int = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< + FiniteNumber, + 'Int' +>; /** * Numeric brand type for value after checking with `Number.isInteger(x)` and @@ -158,7 +220,10 @@ type NegativeInt = IntersectBrand; type NonZeroInt = IntersectBrand; /** Numeric brand type for value after checking with `Number.isSafeInteger(x)` */ -type SafeInt = TSTypeUtilsInternals.ExtendNumberBrand; +type SafeInt = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< + Int, + 'SafeInt' +>; /** * Numeric brand type for value after checking with `Number.isSafeInteger(x)` @@ -190,7 +255,7 @@ type NonZeroSafeInt = IntersectBrand; * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `-2^31 <= x <= 2^31 - 1` */ -type Int32 = TSTypeUtilsInternals.ExtendNumberBrand< +type Int32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< SafeInt, '< 2^31' | '< 2^32' | '> -2^32' | '>= -2^31' >; @@ -201,7 +266,7 @@ type Int32 = TSTypeUtilsInternals.ExtendNumberBrand< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `-2^15 <= x <= 2^15 - 1` */ -type Int16 = TSTypeUtilsInternals.ExtendNumberBrand< +type Int16 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< Int32, '< 2^15' | '< 2^16' | '> -2^16' | '>= -2^15' >; @@ -212,7 +277,10 @@ type Int16 = TSTypeUtilsInternals.ExtendNumberBrand< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `0 <= x <= 2^32 - 1` */ -type Uint32 = TSTypeUtilsInternals.ExtendNumberBrand; +type Uint32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< + SafeUint, + '< 2^32' +>; /** * `[0, 2^16 - 1]` @@ -220,7 +288,7 @@ type Uint32 = TSTypeUtilsInternals.ExtendNumberBrand; * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `0 <= x <= 2^16 - 1` */ -type Uint16 = TSTypeUtilsInternals.ExtendNumberBrand< +type Uint16 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< Uint32, '< 2^16' | '< 2^31' >; @@ -231,7 +299,7 @@ type Uint16 = TSTypeUtilsInternals.ExtendNumberBrand< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `-2^32 < x < 0` */ -type NegativeInt32 = TSTypeUtilsInternals.ExtendNumberBrand< +type NegativeInt32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< IntersectBrand, '> -2^32' >; @@ -242,28 +310,34 @@ type NegativeInt32 = TSTypeUtilsInternals.ExtendNumberBrand< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `-2^16 < x < 0` */ -type NegativeInt16 = TSTypeUtilsInternals.ExtendNumberBrand< +type NegativeInt16 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< NegativeInt32, '> -2^16' | '>= -2^31' >; /** Numeric brand type for `Float32Array` element */ -type Float32 = TSTypeUtilsInternals.ExtendNumberBrand< +type Float32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< TSTypeUtilsInternals.BrandedNumberBaseType, 'Float32' >; /** Numeric brand type for `Float64Array` element */ -type Float64 = TSTypeUtilsInternals.ExtendNumberBrand< +type Float64 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< TSTypeUtilsInternals.BrandedNumberBaseType, 'Float64' >; /** Numeric brand type for `BigInt64Array` element */ -type BigInt64 = ExtendBrand, 'BigInt64'>; +type BigInt64 = ExtendBrand< + ChangeBaseBrand, + NumberBrandKeys__['BigInt64'] +>; /** Numeric brand type for `BigUint64Array` element */ -type BigUint64 = ExtendBrand, 'BigUint64'>; +type BigUint64 = ExtendBrand< + ChangeBaseBrand, + NumberBrandKeys__['BigUint64'] +>; /** * Small integers union diff --git a/packages/ts-type-utils/src/std.d.mts b/packages/ts-type-utils/src/std.d.mts index 4373337346..21337eeda1 100644 --- a/packages/ts-type-utils/src/std.d.mts +++ b/packages/ts-type-utils/src/std.d.mts @@ -92,7 +92,7 @@ interface String {} interface Boolean {} interface Object {} interface RegExp {} -// interface Symbol {} +interface Symbol {} // eslint-disable-next-line @typescript-eslint/no-unused-vars interface ReadonlySet {} diff --git a/packages/ts-type-utils/test/brand.mts b/packages/ts-type-utils/test/brand.mts index 5b0b8c642b..1fb3d3c2bb 100644 --- a/packages/ts-type-utils/test/brand.mts +++ b/packages/ts-type-utils/test/brand.mts @@ -1,9 +1,11 @@ import { expectType } from './expect-type.mjs'; { - type A = Brand; + const _A_Brand: unique symbol = Symbol.for('A_Brand'); - expectType, 'A'>('='); + type A = Brand; + + expectType, typeof _A_Brand>('='); expectType, number>('='); type AB = Brand; diff --git a/packages/utils/ts-utils/src/num/branded-types/finite-number.mts b/packages/utils/ts-utils/src/num/branded-types/finite-number.mts index c6c5929146..ed27a515e4 100644 --- a/packages/utils/ts-utils/src/num/branded-types/finite-number.mts +++ b/packages/utils/ts-utils/src/num/branded-types/finite-number.mts @@ -89,3 +89,9 @@ if (import.meta.vitest !== undefined) { >('='); expectType>('<='); } + +const positiveBrand = Symbol(); + +export type Positive = number & { [positiveBrand]: true }; +export type Negative = number & { [positiveBrand]: false }; +type T = Positive & Negative; From c6caf13db607782185a2b16b256f11c746b0b273 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Thu, 6 Feb 2025 14:16:46 +0900 Subject: [PATCH 10/25] Revert "improve branded type implementation [WIP]" This reverts commit 0d136f4914672e566e971c6565a090f42f8ba747. --- packages/ts-type-utils/src/brand.d.mts | 34 ++--- .../ts-type-utils/src/branded-types.d.mts | 128 ++++-------------- packages/ts-type-utils/src/std.d.mts | 2 +- packages/ts-type-utils/test/brand.mts | 6 +- .../src/num/branded-types/finite-number.mts | 6 - 5 files changed, 47 insertions(+), 129 deletions(-) diff --git a/packages/ts-type-utils/src/brand.d.mts b/packages/ts-type-utils/src/brand.d.mts index 141f07f733..4c769b8f8f 100644 --- a/packages/ts-type-utils/src/brand.d.mts +++ b/packages/ts-type-utils/src/brand.d.mts @@ -1,21 +1,21 @@ type UnknownBrand = Brand; -declare const brandKey: unique symbol; - /** @internal */ declare namespace TSTypeUtilsInternals { + // const brand_: unique symbol; + /** * `ts-type-utils` 外で作られた branded type と競合しないように型を区別する。 * + * MEMO: [gcanti/io-ts](https://github.com/gcanti/io-ts) では unique symbol + * を使っているが 型ライブラリとして独立できるようにするために ts-type-utils では使用していない。 + * * @internal */ type BrandEncapsulated = B & Readonly<{ - [brandKey]: unknown; + 'TSTypeUtilsInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown; }>; - // Readonly<{ - // 'TSTypeUtilsInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown; - // }>; type ExtractTrueKeys = ExtractBooleanKeysImpl< B, @@ -42,7 +42,7 @@ declare namespace TSTypeUtilsInternals { > = K extends K ? (TypeEq extends true ? K : never) : never; } -type Brand = T & +type Brand = T & TSTypeUtilsInternals.BrandEncapsulated<{ readonly [key in FalseKeys | TrueKeys]: key extends TrueKeys ? true : false; }>; @@ -66,35 +66,35 @@ type GetBrandKeysPart = Pick>; type GetBrandValuePart = B extends Brand< infer T, - UnwrapBrandTrueKeys & symbol, - UnwrapBrandFalseKeys & symbol + UnwrapBrandTrueKeys & string, + UnwrapBrandFalseKeys & string > ? T : never; type ExtendBrand< B extends UnknownBrand, - T extends symbol, - F extends symbol = never, + T extends string, + F extends string = never, > = IsNever extends true // T and F shouldn't have intersection ? Brand< GetBrandValuePart, - T | (UnwrapBrandTrueKeys & symbol), - F | (UnwrapBrandFalseKeys & symbol) + T | (UnwrapBrandTrueKeys & string), + F | (UnwrapBrandFalseKeys & string) > : never; type ChangeBaseBrand = Brand< T, - UnwrapBrandTrueKeys & symbol, - UnwrapBrandFalseKeys & symbol + UnwrapBrandTrueKeys & string, + UnwrapBrandFalseKeys & string >; type IntersectBrand = Brand< GetBrandValuePart & GetBrandValuePart, - symbol & (UnwrapBrandTrueKeys | UnwrapBrandTrueKeys), - symbol & (UnwrapBrandFalseKeys | UnwrapBrandFalseKeys) + string & (UnwrapBrandTrueKeys | UnwrapBrandTrueKeys), + string & (UnwrapBrandFalseKeys | UnwrapBrandFalseKeys) >; /** ある key が true | false になる場合、その key を削除する */ diff --git a/packages/ts-type-utils/src/branded-types.d.mts b/packages/ts-type-utils/src/branded-types.d.mts index fd9898e04d..963adae3b8 100644 --- a/packages/ts-type-utils/src/branded-types.d.mts +++ b/packages/ts-type-utils/src/branded-types.d.mts @@ -1,48 +1,6 @@ -/* eslint-disable @typescript-eslint/no-unused-vars */ - -declare const __brandKeyLt2_15__: unique symbol; -declare const __brandKeyLt2_16__: unique symbol; -declare const __brandKeyLt2_31__: unique symbol; -declare const __brandKeyLt2_32__: unique symbol; -declare const __brandKeyGtMinus2_16__: unique symbol; -declare const __brandKeyGtMinus2_32__: unique symbol; -declare const __brandKeyGeMinus2_15__: unique symbol; -declare const __brandKeyGeMinus2_31__: unique symbol; -declare const __brandKeyGe0__: unique symbol; -declare const __brandKeyNe0__: unique symbol; -declare const __brandKeyFinite__: unique symbol; -declare const __brandKeyFloat32__: unique symbol; -declare const __brandKeyFloat64__: unique symbol; -declare const __brandKeyInt__: unique symbol; -declare const __brandKeyNaNValue__: unique symbol; -declare const __brandKeySafeInt__: unique symbol; -declare const __brandKeyBigInt64__: unique symbol; -declare const __brandKeyBigUint64__: unique symbol; - -type NumberBrandKeys__ = Readonly<{ - '< 2^15': typeof __brandKeyLt2_15__; - '< 2^16': typeof __brandKeyLt2_16__; - '< 2^31': typeof __brandKeyLt2_31__; - '< 2^32': typeof __brandKeyLt2_32__; - '> -2^16': typeof __brandKeyGtMinus2_16__; - '> -2^32': typeof __brandKeyGtMinus2_32__; - '>= -2^15': typeof __brandKeyGeMinus2_15__; - '>= -2^31': typeof __brandKeyGeMinus2_31__; - '>=0': typeof __brandKeyGe0__; - '!=0': typeof __brandKeyNe0__; - Finite: typeof __brandKeyFinite__; - Float32: typeof __brandKeyFloat32__; - Float64: typeof __brandKeyFloat64__; - Int: typeof __brandKeyInt__; - NaNValue: typeof __brandKeyNaNValue__; - SafeInt: typeof __brandKeySafeInt__; - BigInt64: typeof __brandKeyBigInt64__; - BigUint64: typeof __brandKeyBigUint64__; -}>; - /** @internal */ declare namespace TSTypeUtilsInternals { - type IntRangeStringKeys = + type IntRangeKeys = | '< 2^15' | '< 2^16' | '< 2^31' @@ -53,8 +11,8 @@ declare namespace TSTypeUtilsInternals { | '>= -2^31' | '>=0'; - type StringKeys_ = - | IntRangeStringKeys + type Keys_ = + | IntRangeKeys | '!=0' | 'Finite' | 'Float32' @@ -63,10 +21,6 @@ declare namespace TSTypeUtilsInternals { | 'NaNValue' | 'SafeInt'; - type IntRangeKeys = NumberBrandKeys__[IntRangeStringKeys]; - - type Keys_ = NumberBrandKeys__[StringKeys_]; - type BrandedNumberBaseType = Brand; type ExtendNumberBrand< @@ -75,18 +29,8 @@ declare namespace TSTypeUtilsInternals { F extends RelaxedExclude> = never, > = Brand< GetBrandValuePart, - T | (UnwrapBrandTrueKeys & symbol), - F | (UnwrapBrandFalseKeys & symbol) - >; - - type ExtendNumberBrandByStringKey< - B extends BrandedNumberBaseType, - T extends RelaxedExclude>, - F extends RelaxedExclude> = never, - > = Brand< - GetBrandValuePart, - NumberBrandKeys__[T] | (UnwrapBrandTrueKeys & symbol), - NumberBrandKeys__[F] | (UnwrapBrandFalseKeys & symbol) + T | (UnwrapBrandTrueKeys & string), + F | (UnwrapBrandFalseKeys & string) >; type SmallIntIndexMax = 40; @@ -101,14 +45,14 @@ declare namespace TSTypeUtilsInternals { } /** Numeric brand type for `NaN` */ -type NaNType = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type NaNType = TSTypeUtilsInternals.ExtendNumberBrand< TSTypeUtilsInternals.BrandedNumberBaseType, '!=0' | 'NaNValue', - TSTypeUtilsInternals.IntRangeStringKeys | '>=0' | 'Finite' | 'Int' | 'SafeInt' + TSTypeUtilsInternals.IntRangeKeys | '>=0' | 'Finite' | 'Int' | 'SafeInt' >; /** Numeric brand type for numbers except `NaN` */ -type ValidNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type ValidNumber = TSTypeUtilsInternals.ExtendNumberBrand< TSTypeUtilsInternals.BrandedNumberBaseType, never, 'NaNValue' @@ -117,24 +61,21 @@ type ValidNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< /** Numeric brand type for value after checking with `Number.isFinite(x)` */ type FiniteNumber = TSTypeUtilsInternals.ExtendNumberBrand< ValidNumber, - NumberBrandKeys__['Finite'] + 'Finite' >; /** Numeric brand type for `Infinity` */ -type InfiniteNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type InfiniteNumber = TSTypeUtilsInternals.ExtendNumberBrand< ValidNumber, '!=0', 'Finite' | 'Int' | 'SafeInt' >; /** Numeric brand type for value after checking with `x != 0` */ -type NonZeroNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< - ValidNumber, - '!=0' ->; +type NonZeroNumber = TSTypeUtilsInternals.ExtendNumberBrand; /** Numeric brand type for value after checking with `x >= 0` */ -type NonNegativeNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type NonNegativeNumber = TSTypeUtilsInternals.ExtendNumberBrand< ValidNumber, '> -2^16' | '> -2^32' | '>= -2^15' | '>= -2^31' | '>=0' >; @@ -143,21 +84,21 @@ type NonNegativeNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< type PositiveNumber = IntersectBrand; /** Numeric brand type for value after checking with `x < 0` */ -type NegativeNumber = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type NegativeNumber = TSTypeUtilsInternals.ExtendNumberBrand< NonZeroNumber, '< 2^15' | '< 2^16' | '< 2^31' | '< 2^32', '>=0' >; /** Numeric brand type for `Number.POSITIVE_INFINITY` */ -type POSITIVE_INFINITY = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type POSITIVE_INFINITY = TSTypeUtilsInternals.ExtendNumberBrand< IntersectBrand, never, '< 2^15' | '< 2^16' | '< 2^31' | '< 2^32' >; /** Numeric brand type for `Number.NEGATIVE_INFINITY` */ -type NEGATIVE_INFINITY = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type NEGATIVE_INFINITY = TSTypeUtilsInternals.ExtendNumberBrand< IntersectBrand, never, '> -2^16' | '> -2^32' | '>= -2^15' | '>= -2^31' @@ -190,10 +131,7 @@ type NegativeFiniteNumber = IntersectBrand; // integer types /** Numeric brand type for value after checking with `Number.isInteger(x)` */ -type Int = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< - FiniteNumber, - 'Int' ->; +type Int = TSTypeUtilsInternals.ExtendNumberBrand; /** * Numeric brand type for value after checking with `Number.isInteger(x)` and @@ -220,10 +158,7 @@ type NegativeInt = IntersectBrand; type NonZeroInt = IntersectBrand; /** Numeric brand type for value after checking with `Number.isSafeInteger(x)` */ -type SafeInt = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< - Int, - 'SafeInt' ->; +type SafeInt = TSTypeUtilsInternals.ExtendNumberBrand; /** * Numeric brand type for value after checking with `Number.isSafeInteger(x)` @@ -255,7 +190,7 @@ type NonZeroSafeInt = IntersectBrand; * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `-2^31 <= x <= 2^31 - 1` */ -type Int32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type Int32 = TSTypeUtilsInternals.ExtendNumberBrand< SafeInt, '< 2^31' | '< 2^32' | '> -2^32' | '>= -2^31' >; @@ -266,7 +201,7 @@ type Int32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `-2^15 <= x <= 2^15 - 1` */ -type Int16 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type Int16 = TSTypeUtilsInternals.ExtendNumberBrand< Int32, '< 2^15' | '< 2^16' | '> -2^16' | '>= -2^15' >; @@ -277,10 +212,7 @@ type Int16 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `0 <= x <= 2^32 - 1` */ -type Uint32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< - SafeUint, - '< 2^32' ->; +type Uint32 = TSTypeUtilsInternals.ExtendNumberBrand; /** * `[0, 2^16 - 1]` @@ -288,7 +220,7 @@ type Uint32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `0 <= x <= 2^16 - 1` */ -type Uint16 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type Uint16 = TSTypeUtilsInternals.ExtendNumberBrand< Uint32, '< 2^16' | '< 2^31' >; @@ -299,7 +231,7 @@ type Uint16 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `-2^32 < x < 0` */ -type NegativeInt32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type NegativeInt32 = TSTypeUtilsInternals.ExtendNumberBrand< IntersectBrand, '> -2^32' >; @@ -310,34 +242,28 @@ type NegativeInt32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< * Numeric brand type for value after checking with `Number.isSafeInteger(x)` * and `-2^16 < x < 0` */ -type NegativeInt16 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type NegativeInt16 = TSTypeUtilsInternals.ExtendNumberBrand< NegativeInt32, '> -2^16' | '>= -2^31' >; /** Numeric brand type for `Float32Array` element */ -type Float32 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type Float32 = TSTypeUtilsInternals.ExtendNumberBrand< TSTypeUtilsInternals.BrandedNumberBaseType, 'Float32' >; /** Numeric brand type for `Float64Array` element */ -type Float64 = TSTypeUtilsInternals.ExtendNumberBrandByStringKey< +type Float64 = TSTypeUtilsInternals.ExtendNumberBrand< TSTypeUtilsInternals.BrandedNumberBaseType, 'Float64' >; /** Numeric brand type for `BigInt64Array` element */ -type BigInt64 = ExtendBrand< - ChangeBaseBrand, - NumberBrandKeys__['BigInt64'] ->; +type BigInt64 = ExtendBrand, 'BigInt64'>; /** Numeric brand type for `BigUint64Array` element */ -type BigUint64 = ExtendBrand< - ChangeBaseBrand, - NumberBrandKeys__['BigUint64'] ->; +type BigUint64 = ExtendBrand, 'BigUint64'>; /** * Small integers union diff --git a/packages/ts-type-utils/src/std.d.mts b/packages/ts-type-utils/src/std.d.mts index 21337eeda1..4373337346 100644 --- a/packages/ts-type-utils/src/std.d.mts +++ b/packages/ts-type-utils/src/std.d.mts @@ -92,7 +92,7 @@ interface String {} interface Boolean {} interface Object {} interface RegExp {} -interface Symbol {} +// interface Symbol {} // eslint-disable-next-line @typescript-eslint/no-unused-vars interface ReadonlySet {} diff --git a/packages/ts-type-utils/test/brand.mts b/packages/ts-type-utils/test/brand.mts index 1fb3d3c2bb..5b0b8c642b 100644 --- a/packages/ts-type-utils/test/brand.mts +++ b/packages/ts-type-utils/test/brand.mts @@ -1,11 +1,9 @@ import { expectType } from './expect-type.mjs'; { - const _A_Brand: unique symbol = Symbol.for('A_Brand'); + type A = Brand; - type A = Brand; - - expectType, typeof _A_Brand>('='); + expectType, 'A'>('='); expectType, number>('='); type AB = Brand; diff --git a/packages/utils/ts-utils/src/num/branded-types/finite-number.mts b/packages/utils/ts-utils/src/num/branded-types/finite-number.mts index ed27a515e4..c6c5929146 100644 --- a/packages/utils/ts-utils/src/num/branded-types/finite-number.mts +++ b/packages/utils/ts-utils/src/num/branded-types/finite-number.mts @@ -89,9 +89,3 @@ if (import.meta.vitest !== undefined) { >('='); expectType>('<='); } - -const positiveBrand = Symbol(); - -export type Positive = number & { [positiveBrand]: true }; -export type Negative = number & { [positiveBrand]: false }; -type T = Positive & Negative; From cc84bcd9c2b749e17388756f35250d6789b7e8c4 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Mon, 9 Jan 2023 16:12:06 +0900 Subject: [PATCH 11/25] -------- --- docs/------------ | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/------------ diff --git a/docs/------------ b/docs/------------ new file mode 100644 index 0000000000..e69de29bb2 From 5ed462ff292525cdda778a19b3ed1ed00e335303 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sun, 1 Oct 2023 15:09:51 +0900 Subject: [PATCH 12/25] feat: ts-utils: add Num.add [WIP] --- packages/utils/ts-utils/src/num/num.mts | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/packages/utils/ts-utils/src/num/num.mts b/packages/utils/ts-utils/src/num/num.mts index 2ea80b4a12..079586fb32 100644 --- a/packages/utils/ts-utils/src/num/num.mts +++ b/packages/utils/ts-utils/src/num/num.mts @@ -75,6 +75,21 @@ const div = (a: number, b: NonZeroNumber | SmallInt<'!=0'>): number => // eslint-disable-next-line total-functions/no-partial-division a / b; +// TODO: generate code +function add( + a: PositiveFiniteNumber, + b: NonNegativeFiniteNumber, +): PositiveFiniteNumber; +function add( + a: NonNegativeFiniteNumber, + b: PositiveFiniteNumber, +): PositiveFiniteNumber; +function add(a: FiniteNumber, b: FiniteNumber): FiniteNumber; +function add(a: FiniteNumber, b: FiniteNumber): FiniteNumber { + // eslint-disable-next-line total-functions/no-unsafe-type-assertion + return (a + b) as FiniteNumber; +} + // ValidNumber // FiniteNumber // NonZeroNumber @@ -152,6 +167,7 @@ export const Num = { isNonNegative, isPositive, div, + add, clamp, roundAt, roundBy, From 1036e63d256a0d07a77965abea35478828318d12 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sun, 9 Oct 2022 18:28:39 +0900 Subject: [PATCH 13/25] -------- --- docs/--- | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/--- diff --git a/docs/--- b/docs/--- new file mode 100644 index 0000000000..e69de29bb2 From 2b66d2f51eeb508416bdd4c3b3ef81347d9035e7 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Fri, 31 Jan 2025 08:02:17 +0900 Subject: [PATCH 14/25] feat: [event-schedule-app] archiveAll --- .../pages/event-list-page/event-list-page.tsx | 29 +++++++++++++------ .../constants/dictionary/event-list-page.ts | 1 + 2 files changed, 21 insertions(+), 9 deletions(-) diff --git a/packages/apps/event-schedule-app/src/components/pages/event-list-page/event-list-page.tsx b/packages/apps/event-schedule-app/src/components/pages/event-list-page/event-list-page.tsx index ed246462d8..2e32ee25fb 100644 --- a/packages/apps/event-schedule-app/src/components/pages/event-list-page/event-list-page.tsx +++ b/packages/apps/event-schedule-app/src/components/pages/event-list-page/event-list-page.tsx @@ -128,15 +128,26 @@ export const EventListPage = memoNamed('EventListPage', () => { `} >
    {dc.itemCount(Arr.length(eventListWithHandler))}
    - +
    + + +
    `${n}件`, From 5f3c0a90e212e6e5e51cf3c356ce91f4f7da10f5 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Fri, 31 Jan 2025 09:22:48 +0900 Subject: [PATCH 15/25] feat: [event-schedule-app] add createdAt, updatedAt [WIP] --- .../src/v9/types/record/answer.mts | 7 ++++--- .../src/v9/types/record/answer.test.mts | 8 +++++--- .../src/v9/types/record/event-schedule.mts | 4 ++++ .../src/v9/types/record/event-schedule.test.mts | 4 ++++ .../apps/event-schedule-app/src/api/crud/fetch-answers.ts | 8 ++------ .../event-schedule-app/src/constants/initial-values.ts | 4 ++++ .../src/functions/event-settings-page-diff.ts | 2 ++ .../src/functions/normalize-event-schedule.ts | 4 ++++ .../event-schedule-setting-common.ts | 7 +++++++ 9 files changed, 36 insertions(+), 12 deletions(-) diff --git a/packages/apps/event-schedule-app-shared/src/v9/types/record/answer.mts b/packages/apps/event-schedule-app-shared/src/v9/types/record/answer.mts index 6bc5965ef1..8acce5e6b5 100644 --- a/packages/apps/event-schedule-app-shared/src/v9/types/record/answer.mts +++ b/packages/apps/event-schedule-app-shared/src/v9/types/record/answer.mts @@ -3,16 +3,17 @@ import { AnswerId, Weight } from '../named-primitive-types.mjs'; import { AnswerSelection } from './answer-selection.mjs'; import { User } from './base/index.mjs'; -export const ANSWER_KEY_CREATED_AT = 'createdAt'; - export const Answer = t.record({ id: AnswerId, user: User, comment: t.string(''), selection: t.array(AnswerSelection), - [ANSWER_KEY_CREATED_AT]: t.number(0), weight: Weight, isRequiredParticipants: t.boolean(false), + /** Unix time (milliseconds) */ + createdAt: t.number(0), + /** Unix time (milliseconds) */ + updatedAt: t.number(0), }); export type Answer = t.TypeOf; diff --git a/packages/apps/event-schedule-app-shared/src/v9/types/record/answer.test.mts b/packages/apps/event-schedule-app-shared/src/v9/types/record/answer.test.mts index 4716407a98..99548212e8 100644 --- a/packages/apps/event-schedule-app-shared/src/v9/types/record/answer.test.mts +++ b/packages/apps/event-schedule-app-shared/src/v9/types/record/answer.test.mts @@ -1,7 +1,7 @@ import { expectType } from '@noshiro/ts-utils'; import { AnswerId, Weight } from '../named-primitive-types.mjs'; import { type AnswerSelection } from './answer-selection.mjs'; -import { ANSWER_KEY_CREATED_AT, Answer } from './answer.mjs'; +import { Answer } from './answer.mjs'; import { User } from './base/index.mjs'; describe('Answer', () => { @@ -12,7 +12,8 @@ describe('Answer', () => { user: User; comment: string; selection: readonly AnswerSelection[]; - [ANSWER_KEY_CREATED_AT]: number; + createdAt: number; + updatedAt: number; weight: Weight; isRequiredParticipants: boolean; }> @@ -24,7 +25,8 @@ describe('Answer', () => { user: User.defaultValue, comment: '', selection: [], - [ANSWER_KEY_CREATED_AT]: 0, + createdAt: 0, + updatedAt: 0, weight: Weight.cast(1), isRequiredParticipants: false, }; diff --git a/packages/apps/event-schedule-app-shared/src/v9/types/record/event-schedule.mts b/packages/apps/event-schedule-app-shared/src/v9/types/record/event-schedule.mts index 99ec5ef709..1e004da2aa 100644 --- a/packages/apps/event-schedule-app-shared/src/v9/types/record/event-schedule.mts +++ b/packages/apps/event-schedule-app-shared/src/v9/types/record/event-schedule.mts @@ -23,6 +23,10 @@ export const EventSchedule = t.record({ timezoneOffsetMinutes: t.number(DateUtils.today().getTimezoneOffset()), author: User, archivedBy: t.array(User), + /** Unix time (milliseconds) */ + createdAt: t.number(0), + /** Unix time (milliseconds) */ + updatedAt: t.number(0), }); export type EventSchedule = t.TypeOf; diff --git a/packages/apps/event-schedule-app-shared/src/v9/types/record/event-schedule.test.mts b/packages/apps/event-schedule-app-shared/src/v9/types/record/event-schedule.test.mts index 4335b472a3..0d20387c89 100644 --- a/packages/apps/event-schedule-app-shared/src/v9/types/record/event-schedule.test.mts +++ b/packages/apps/event-schedule-app-shared/src/v9/types/record/event-schedule.test.mts @@ -23,6 +23,8 @@ describe('EventSchedule', () => { timezoneOffsetMinutes: number; author: User; archivedBy: readonly User[]; + createdAt: number; + updatedAt: number; }> >('='); @@ -42,6 +44,8 @@ describe('EventSchedule', () => { timezoneOffsetMinutes: DateUtils.today().getTimezoneOffset(), author: User.defaultValue, archivedBy: [], + createdAt: 0, + updatedAt: 0, }; expect(EventSchedule.defaultValue).toStrictEqual(defaultValue); diff --git a/packages/apps/event-schedule-app/src/api/crud/fetch-answers.ts b/packages/apps/event-schedule-app/src/api/crud/fetch-answers.ts index 9b8c0d61e0..5c44d4a505 100644 --- a/packages/apps/event-schedule-app/src/api/crud/fetch-answers.ts +++ b/packages/apps/event-schedule-app/src/api/crud/fetch-answers.ts @@ -1,8 +1,4 @@ -import { - ANSWER_KEY_CREATED_AT, - Answer, - firestorePaths, -} from '@noshiro/event-schedule-app-shared'; +import { Answer, firestorePaths } from '@noshiro/event-schedule-app-shared'; import { collection, getDocs, orderBy, query } from 'firebase/firestore'; import { firestoreEvents } from '../../initialize-firebase'; @@ -15,7 +11,7 @@ export const fetchAnswers = ( getDocs( query( collection(firestoreEvents, eventId, firestorePaths.answers), - orderBy(ANSWER_KEY_CREATED_AT, 'asc'), + orderBy('createdAt' satisfies keyof Pick, 'asc'), ), ), ).then((a) => diff --git a/packages/apps/event-schedule-app/src/constants/initial-values.ts b/packages/apps/event-schedule-app/src/constants/initial-values.ts index 556179aaee..d1d2440187 100644 --- a/packages/apps/event-schedule-app/src/constants/initial-values.ts +++ b/packages/apps/event-schedule-app/src/constants/initial-values.ts @@ -70,4 +70,8 @@ export const eventScheduleInitialValue: EventSchedule = { name: UserName.cast(''), }, archivedBy: [], + + // TODO: fix createdAt and updatedAt value + createdAt: Date.now(), + updatedAt: Date.now(), }; diff --git a/packages/apps/event-schedule-app/src/functions/event-settings-page-diff.ts b/packages/apps/event-schedule-app/src/functions/event-settings-page-diff.ts index 31fb5d3397..68ccc0053b 100644 --- a/packages/apps/event-schedule-app/src/functions/event-settings-page-diff.ts +++ b/packages/apps/event-schedule-app/src/functions/event-settings-page-diff.ts @@ -85,6 +85,8 @@ type EventSchedulePaths = Exclude, readonly []>; | ['notificationSettings'] | ['timezoneOffsetMinutes'] | ['title'] + | ['createdAt'] + | ['updatedAt'] >, EventSchedulePaths >('='); diff --git a/packages/apps/event-schedule-app/src/functions/normalize-event-schedule.ts b/packages/apps/event-schedule-app/src/functions/normalize-event-schedule.ts index 862b4d5bad..282c6dae04 100644 --- a/packages/apps/event-schedule-app/src/functions/normalize-event-schedule.ts +++ b/packages/apps/event-schedule-app/src/functions/normalize-event-schedule.ts @@ -16,4 +16,8 @@ export const normalizeEventSchedule = ( timezoneOffsetMinutes: eventSchedule.timezoneOffsetMinutes, author: eventSchedule.author, archivedBy: eventSchedule.archivedBy, + + // TODO: fix createdAt and updatedAt value + createdAt: Date.now(), + updatedAt: Date.now(), }); diff --git a/packages/apps/event-schedule-app/src/store/create-event-schedule-page/event-schedule-setting-common.ts b/packages/apps/event-schedule-app/src/store/create-event-schedule-page/event-schedule-setting-common.ts index acfb08654f..307ae68408 100644 --- a/packages/apps/event-schedule-app/src/store/create-event-schedule-page/event-schedule-setting-common.ts +++ b/packages/apps/event-schedule-app/src/store/create-event-schedule-page/event-schedule-setting-common.ts @@ -205,6 +205,10 @@ export const createEventScheduleSettingStore = (): ReturnValues => { name: UserName.cast(fireAuthUser?.displayName ?? ''), }, archivedBy: [], + + // TODO: fix createdAt and updatedAt value + createdAt: Date.now(), + updatedAt: Date.now(), }), ), ); @@ -229,6 +233,9 @@ export const createEventScheduleSettingStore = (): ReturnValues => { answerIcons, notificationSettingsWithEmail: notificationSettingsWithEmail ?? 'none', + // TODO: fix createdAt and updatedAt value + createdAt: Date.now(), + updatedAt: Date.now(), }), ), ); From 395b82136bc74e8921d67bde77a850df0afa7730 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Mon, 9 Jan 2023 16:12:08 +0900 Subject: [PATCH 16/25] -------- --- docs/------------- | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/------------- diff --git a/docs/------------- b/docs/------------- new file mode 100644 index 0000000000..e69de29bb2 From bb73a2f530316c7b4bd8c15b5000da03cb7e1a9d Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Mon, 10 Feb 2025 03:14:24 +0900 Subject: [PATCH 17/25] refactor: [eslint-config] add RuleSeverityWithDefaultOption type --- .../scripts/generate-rules-type.mts | 53 +- .../src/rules/eslint-cypress-rules.mts | 3 +- .../src/rules/eslint-functional-rules.mts | 5 +- .../src/rules/eslint-import-rules.mts | 19 +- .../src/rules/eslint-jest-rules.mts | 19 +- .../src/rules/eslint-jsx-a11y-rules.mts | 69 +- .../src/rules/eslint-playwright-rules.mts | 21 +- .../src/rules/eslint-plugin-rules.mts | 23 +- .../src/rules/eslint-promise-rules.mts | 9 +- .../src/rules/eslint-react-hooks-rules.mts | 3 +- .../src/rules/eslint-react-refresh-rules.mts | 3 +- .../src/rules/eslint-react-rules.mts | 85 ++- .../eslint-configs/src/rules/eslint-rules.mts | 93 +-- .../rules/eslint-testing-library-rules.mts | 11 +- .../src/rules/eslint-unicorn-rules.mts | 37 +- .../src/rules/eslint-vitest-rules.mts | 19 +- .../src/rules/typescript-eslint-rules.mts | 74 +- packages/eslint-configs/src/types/index.mts | 1 + .../src/types/rule-severity-branded.mts | 19 + .../types/rules/eslint-array-func-rules.mts | 12 +- .../src/types/rules/eslint-cypress-rules.mts | 31 +- .../types/rules/eslint-functional-rules.mts | 94 ++- .../src/types/rules/eslint-import-rules.mts | 180 +++-- .../src/types/rules/eslint-jest-rules.mts | 186 +++-- .../src/types/rules/eslint-jsx-a11y-rules.mts | 188 +++-- .../types/rules/eslint-playwright-rules.mts | 151 ++-- .../src/types/rules/eslint-plugin-rules.mts | 103 +-- .../eslint-prefer-arrow-functions-rules.mts | 13 +- .../src/types/rules/eslint-promise-rules.mts | 66 +- .../types/rules/eslint-react-hooks-rules.mts | 15 +- .../rules/eslint-react-refresh-rules.mts | 13 +- .../src/types/rules/eslint-react-rules.mts | 423 +++++----- .../src/types/rules/eslint-rules.mts | 721 ++++++++++-------- .../src/types/rules/eslint-security-rules.mts | 28 +- .../eslint-strict-dependencies-rules.mts | 8 +- .../rules/eslint-testing-library-rules.mts | 98 ++- .../rules/eslint-total-functions-rules.mts | 24 +- .../rules/eslint-tree-shakable-rules.mts | 2 +- .../src/types/rules/eslint-unicorn-rules.mts | 344 +++++---- .../src/types/rules/eslint-vitest-rules.mts | 164 ++-- .../types/rules/typescript-eslint-rules.mts | 468 +++++++----- 41 files changed, 2233 insertions(+), 1665 deletions(-) create mode 100644 packages/eslint-configs/src/types/rule-severity-branded.mts diff --git a/packages/eslint-configs/scripts/generate-rules-type.mts b/packages/eslint-configs/scripts/generate-rules-type.mts index 267c2fe3cd..1e417f82a8 100644 --- a/packages/eslint-configs/scripts/generate-rules-type.mts +++ b/packages/eslint-configs/scripts/generate-rules-type.mts @@ -2,7 +2,7 @@ import { toSafeUint, toUint32 } from '@noshiro/mono-utils'; import { type Rule } from 'eslint'; import { builtinRules } from 'eslint/use-at-your-own-risk'; import { type JSONSchema4 } from 'json-schema'; -import { compile } from 'json-schema-to-typescript'; +import { compile, type Options } from 'json-schema-to-typescript'; import { deepCopy, deepReplace, @@ -20,10 +20,23 @@ type Meta = DeepReadonly< }> >; +const generatorOption: Readonly<{ + explicitRuleDefaultOption: boolean; +}> = { + explicitRuleDefaultOption: true, +} as const; + +const RuleSeverityWithDefaultOption = 'RuleSeverityWithDefaultOption'; + +const RuleSeverity = generatorOption.explicitRuleDefaultOption + ? 'Linter.StringSeverity' + : 'Linter.RuleSeverity'; + const compilerConfig = { bannerComment: '', format: false, -} as const; + unknownAny: true, +} as const satisfies Partial; const normalizeToSchemaArray = ( schema: DeepReadonly | undefined, @@ -142,11 +155,12 @@ const createResult = async ( const mut_resultToWrite: string[] = [ '/* cSpell:disable */', "import { type Linter } from 'eslint';", + "import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs';", ...(schemaList.some(({ schema }) => schema.length === 1) ? [ '', - 'type SpreadOptionsIfIsArray =', - 'T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T;', + `type SpreadOptionsIfIsArray =`, + `T[1] extends readonly unknown[] ? readonly [${RuleSeverity}, ...T[1]] : T;`, ] : []), '', @@ -163,9 +177,7 @@ const createResult = async ( } else { switch (schema.length) { case 0: - mut_resultToWrite.push( - ' export type RuleEntry = Linter.RuleSeverity;', - ); + mut_resultToWrite.push(` export type RuleEntry = ${RuleSeverity};`); break; case 1: { @@ -189,8 +201,11 @@ const createResult = async ( mut_resultToWrite.push( optionsType, '', - ' export type RuleEntry = Linter.RuleSeverity', - ' | SpreadOptionsIfIsArray;', + ' export type RuleEntry = ', + generatorOption.explicitRuleDefaultOption + ? `"off" | ${RuleSeverityWithDefaultOption}` + : 'Linter.StringSeverity', + ` | SpreadOptionsIfIsArray;`, ); break; } @@ -219,13 +234,15 @@ const createResult = async ( mut_resultToWrite.push( ...optionsTypeList, '', - ' export type RuleEntry = Linter.RuleSeverity', + ' export type RuleEntry = ', + generatorOption.explicitRuleDefaultOption + ? `"off" | ${RuleSeverityWithDefaultOption}` + : 'Linter.RuleSeverity', ...OptionsStrs.map( (_, i) => - ` | readonly [Linter.RuleSeverity, ${OptionsStrs.slice( - 0, - toUint32(i + 1), - ).join(', ')}]`, + ` | readonly [${ + RuleSeverity + }, ${OptionsStrs.slice(0, toUint32(i + 1)).join(', ')}]`, ), ); break; @@ -238,7 +255,7 @@ const createResult = async ( const deprecatedSchemaList = schemaList.filter((s) => s.deprecated); mut_resultToWrite.push( - `export type ${typeName} = {`, + `export type ${typeName} = Readonly<{`, ...schemaList .filter((s) => !s.deprecated) @@ -262,14 +279,14 @@ const createResult = async ( ), ]), - '}', + '}>', '', ); if (schemaList.some((s) => !s.deprecated && s.schema.length > 0)) { mut_resultToWrite.push( - `export type ${typeName}Option = {`, + `export type ${typeName}Option = Readonly<{`, ...schemaList .filter((s) => !s.deprecated && s.schema.length > 0) @@ -286,7 +303,7 @@ const createResult = async ( ].join(''), ), - '}', + '}>', ); } diff --git a/packages/eslint-configs/src/rules/eslint-cypress-rules.mts b/packages/eslint-configs/src/rules/eslint-cypress-rules.mts index f0bdc80b9c..f95fc64cbc 100644 --- a/packages/eslint-configs/src/rules/eslint-cypress-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-cypress-rules.mts @@ -1,4 +1,5 @@ import { type EslintCypressRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintCypressRules: EslintCypressRules = { 'cypress/no-assigning-return-values': 'error', @@ -8,7 +9,7 @@ export const eslintCypressRules: EslintCypressRules = { 'cypress/require-data-selectors': 'off', 'cypress/no-force': 'error', 'cypress/no-pause': 'error', - 'cypress/unsafe-to-chain-command': 'error', + 'cypress/unsafe-to-chain-command': withDefaultOption('error'), 'cypress/no-async-before': 'error', 'cypress/no-debug': 'error', } as const; diff --git a/packages/eslint-configs/src/rules/eslint-functional-rules.mts b/packages/eslint-configs/src/rules/eslint-functional-rules.mts index d5065dee7b..89c4fa77f0 100644 --- a/packages/eslint-configs/src/rules/eslint-functional-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-functional-rules.mts @@ -2,6 +2,7 @@ import { type EslintFunctionalRules, type EslintFunctionalRulesOption, } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const ignoredMutablePattern = [ '^draft', // allow immer.js draft object @@ -53,7 +54,7 @@ export const eslintFunctionalRules: EslintFunctionalRules = { // No Mutations Rules 'functional/immutable-data': ['error', immutableDataOptions], 'functional/no-let': ['error', noLetOptions], - 'functional/prefer-property-signatures': 'error', + 'functional/prefer-property-signatures': withDefaultOption('error'), // 'functional/prefer-readonly-type': ['warn', preferReadonlyTypeOptions], // No Object-Orientation Rules @@ -141,7 +142,7 @@ export const eslintFunctionalRules: EslintFunctionalRules = { // }, // ], - 'functional/no-class-inheritance': 'error', + 'functional/no-class-inheritance': withDefaultOption('error'), // deprecated 'functional/prefer-readonly-type': 0, diff --git a/packages/eslint-configs/src/rules/eslint-import-rules.mts b/packages/eslint-configs/src/rules/eslint-import-rules.mts index c2a8148883..769963d6c2 100644 --- a/packages/eslint-configs/src/rules/eslint-import-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-import-rules.mts @@ -1,4 +1,5 @@ import { type EslintImportsRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintImportsRules: EslintImportsRules = { // TypeScript を使っている場合このチェックは必要ない。 @@ -6,10 +7,10 @@ export const eslintImportsRules: EslintImportsRules = { 'import/named': 'off', 'import/default': 'error', - 'import/namespace': 'error', + 'import/namespace': withDefaultOption('error'), 'import/no-restricted-paths': 'off', // TODO - 'import/no-absolute-path': 'error', - 'import/no-dynamic-require': 'error', + 'import/no-absolute-path': withDefaultOption('error'), + 'import/no-dynamic-require': withDefaultOption('error'), 'import/no-internal-modules': [ 'error', { @@ -36,14 +37,14 @@ export const eslintImportsRules: EslintImportsRules = { ], 'import/no-webpack-loader-syntax': 'error', 'import/no-self-import': 'error', - 'import/no-cycle': 'error', - 'import/no-useless-path-segments': 'error', + 'import/no-cycle': withDefaultOption('error'), + 'import/no-useless-path-segments': withDefaultOption('error'), 'import/no-relative-parent-imports': 'off', // relates to @typescript-eslint/consistent-type-imports rule 'import/consistent-type-specifier-style': ['error', 'prefer-inline'], - 'import/no-relative-packages': 'error', + 'import/no-relative-packages': withDefaultOption('error'), // helpfulWarnings 'import/export': 'error', @@ -69,7 +70,7 @@ export const eslintImportsRules: EslintImportsRules = { // styleGuide 'import/first': ['error', 'absolute-first'], 'import/exports-last': 'off', - 'import/no-duplicates': 'error', + 'import/no-duplicates': withDefaultOption('error'), 'import/no-namespace': 'off', 'import/extensions': [ 'error', @@ -114,9 +115,9 @@ export const eslintImportsRules: EslintImportsRules = { 'import/no-default-export': 'error', 'import/no-named-export': 'off', - 'import/no-anonymous-default-export': 'error', + 'import/no-anonymous-default-export': withDefaultOption('error'), 'import/group-exports': 'off', - 'import/dynamic-import-chunkname': 'error', + 'import/dynamic-import-chunkname': withDefaultOption('error'), 'import/no-empty-named-blocks': 'error', // deprecated rules diff --git a/packages/eslint-configs/src/rules/eslint-jest-rules.mts b/packages/eslint-configs/src/rules/eslint-jest-rules.mts index 20bde4c96b..ebd8f6bfa6 100644 --- a/packages/eslint-configs/src/rules/eslint-jest-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-jest-rules.mts @@ -1,15 +1,16 @@ import { type EslintJestRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintJestRules: EslintJestRules = { /* vitest, playwright と共通のルール（設定値をなるべく合わせる） */ - 'jest/expect-expect': 'error', + 'jest/expect-expect': withDefaultOption('error'), 'jest/max-expects': 'off', - 'jest/max-nested-describe': 'error', + 'jest/max-nested-describe': withDefaultOption('error'), 'jest/no-commented-out-tests': 'off', 'jest/no-conditional-expect': 'error', 'jest/no-conditional-in-test': 'off', 'jest/no-duplicate-hooks': 'error', - 'jest/no-hooks': 'error', + 'jest/no-hooks': withDefaultOption('error'), 'jest/no-restricted-matchers': [ 'error', { @@ -17,7 +18,7 @@ export const eslintJestRules: EslintJestRules = { toBeFalsy: 'Use `.toBe(false)` instead.', }, ], - 'jest/no-standalone-expect': 'error', + 'jest/no-standalone-expect': withDefaultOption('error'), 'jest/prefer-comparison-matcher': 'error', 'jest/prefer-equality-matcher': 'error', 'jest/prefer-hooks-in-order': 'error', @@ -30,7 +31,7 @@ export const eslintJestRules: EslintJestRules = { 'jest/require-to-throw-message': 'error', 'jest/require-top-level-describe': 'off', 'jest/valid-describe-callback': 'error', - 'jest/valid-expect': 'error', + 'jest/valid-expect': withDefaultOption('error'), 'jest/valid-title': 'off', /* vitest と共通のルール（設定値をなるべく合わせる） */ @@ -40,7 +41,7 @@ export const eslintJestRules: EslintJestRules = { 'jest/no-focused-tests': 'error', 'jest/no-identical-title': 'error', 'jest/no-interpolation-in-snapshots': 'error', - 'jest/no-large-snapshots': 'error', + 'jest/no-large-snapshots': withDefaultOption('error'), 'jest/no-mocks-import': 'error', 'jest/no-restricted-jest-methods': [ 'error', @@ -57,7 +58,7 @@ export const eslintJestRules: EslintJestRules = { 'jest/prefer-expect-resolves': 'error', 'jest/prefer-lowercase-title': 'off', 'jest/prefer-mock-promise-shorthand': 'error', - 'jest/prefer-snapshot-hint': 'error', + 'jest/prefer-snapshot-hint': withDefaultOption('error'), 'jest/prefer-spy-on': 'error', 'jest/prefer-todo': 'error', @@ -77,8 +78,8 @@ export const eslintJestRules: EslintJestRules = { 'jest/padding-around-describe-blocks': 'error', 'jest/padding-around-expect-groups': 'error', 'jest/padding-around-test-blocks': 'error', - 'jest/prefer-importing-jest-globals': 'error', + 'jest/prefer-importing-jest-globals': withDefaultOption('error'), 'jest/prefer-jest-mocked': 'error', - 'jest/unbound-method': 'error', + 'jest/unbound-method': withDefaultOption('error'), 'jest/valid-expect-in-promise': 'error', } as const; diff --git a/packages/eslint-configs/src/rules/eslint-jsx-a11y-rules.mts b/packages/eslint-configs/src/rules/eslint-jsx-a11y-rules.mts index f9fb8487f5..3e40f5bd00 100644 --- a/packages/eslint-configs/src/rules/eslint-jsx-a11y-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-jsx-a11y-rules.mts @@ -1,25 +1,26 @@ import { type EslintJsxA11yRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; /** @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/src/index.js */ export const eslintJsxA11yRules: EslintJsxA11yRules = { - 'jsx-a11y/alt-text': 'error', - 'jsx-a11y/anchor-ambiguous-text': 'error', - 'jsx-a11y/anchor-has-content': 'error', - 'jsx-a11y/anchor-is-valid': 'error', - 'jsx-a11y/aria-activedescendant-has-tabindex': 'error', - 'jsx-a11y/aria-props': 'error', - 'jsx-a11y/aria-proptypes': 'error', - 'jsx-a11y/aria-role': 'error', - 'jsx-a11y/aria-unsupported-elements': 'error', - 'jsx-a11y/autocomplete-valid': 'error', - 'jsx-a11y/click-events-have-key-events': 'error', + 'jsx-a11y/alt-text': withDefaultOption('error'), + 'jsx-a11y/anchor-ambiguous-text': withDefaultOption('error'), + 'jsx-a11y/anchor-has-content': withDefaultOption('error'), + 'jsx-a11y/anchor-is-valid': withDefaultOption('error'), + 'jsx-a11y/aria-activedescendant-has-tabindex': withDefaultOption('error'), + 'jsx-a11y/aria-props': withDefaultOption('error'), + 'jsx-a11y/aria-proptypes': withDefaultOption('error'), + 'jsx-a11y/aria-role': withDefaultOption('error'), + 'jsx-a11y/aria-unsupported-elements': withDefaultOption('error'), + 'jsx-a11y/autocomplete-valid': withDefaultOption('error'), + 'jsx-a11y/click-events-have-key-events': withDefaultOption('error'), 'jsx-a11y/control-has-associated-label': 'off', - 'jsx-a11y/heading-has-content': 'error', - 'jsx-a11y/html-has-lang': 'error', - 'jsx-a11y/iframe-has-title': 'error', - 'jsx-a11y/img-redundant-alt': 'error', + 'jsx-a11y/heading-has-content': withDefaultOption('error'), + 'jsx-a11y/html-has-lang': withDefaultOption('error'), + 'jsx-a11y/iframe-has-title': withDefaultOption('error'), + 'jsx-a11y/img-redundant-alt': withDefaultOption('error'), 'jsx-a11y/interactive-supports-focus': [ 'error', @@ -51,14 +52,14 @@ export const eslintJsxA11yRules: EslintJsxA11yRules = { }, ], - 'jsx-a11y/label-has-associated-control': 'error', - 'jsx-a11y/lang': 'error', - 'jsx-a11y/media-has-caption': 'error', - 'jsx-a11y/mouse-events-have-key-events': 'error', - 'jsx-a11y/no-access-key': 'error', - 'jsx-a11y/no-aria-hidden-on-focusable': 'error', - 'jsx-a11y/no-autofocus': 'error', - 'jsx-a11y/no-distracting-elements': 'error', + 'jsx-a11y/label-has-associated-control': withDefaultOption('error'), + 'jsx-a11y/lang': withDefaultOption('error'), + 'jsx-a11y/media-has-caption': withDefaultOption('error'), + 'jsx-a11y/mouse-events-have-key-events': withDefaultOption('error'), + 'jsx-a11y/no-access-key': withDefaultOption('error'), + 'jsx-a11y/no-aria-hidden-on-focusable': withDefaultOption('error'), + 'jsx-a11y/no-autofocus': withDefaultOption('error'), + 'jsx-a11y/no-distracting-elements': withDefaultOption('error'), /* recommended */ // 'jsx-a11y/no-interactive-element-to-noninteractive-role': [ @@ -69,7 +70,8 @@ export const eslintJsxA11yRules: EslintJsxA11yRules = { // }, // ], /* strict */ - 'jsx-a11y/no-interactive-element-to-noninteractive-role': 'error', + 'jsx-a11y/no-interactive-element-to-noninteractive-role': + withDefaultOption('error'), /* recommended */ // 'jsx-a11y/no-noninteractive-element-interactions': [ @@ -131,7 +133,8 @@ export const eslintJsxA11yRules: EslintJsxA11yRules = { // }, // ], /* strict */ - 'jsx-a11y/no-noninteractive-element-to-interactive-role': 'error', + 'jsx-a11y/no-noninteractive-element-to-interactive-role': + withDefaultOption('error'), /* recommended */ // 'jsx-a11y/no-noninteractive-tabindex': [ @@ -143,9 +146,9 @@ export const eslintJsxA11yRules: EslintJsxA11yRules = { // }, // ], /* strict */ - 'jsx-a11y/no-noninteractive-tabindex': 'error', + 'jsx-a11y/no-noninteractive-tabindex': withDefaultOption('error'), - 'jsx-a11y/no-redundant-roles': 'error', + 'jsx-a11y/no-redundant-roles': withDefaultOption('error'), /* recommended */ // 'jsx-a11y/no-static-element-interactions': [ @@ -163,13 +166,13 @@ export const eslintJsxA11yRules: EslintJsxA11yRules = { // }, // ], /* strict */ - 'jsx-a11y/no-static-element-interactions': 'error', + 'jsx-a11y/no-static-element-interactions': withDefaultOption('error'), - 'jsx-a11y/prefer-tag-over-role': 'error', - 'jsx-a11y/role-has-required-aria-props': 'error', - 'jsx-a11y/role-supports-aria-props': 'error', - 'jsx-a11y/scope': 'error', - 'jsx-a11y/tabindex-no-positive': 'error', + 'jsx-a11y/prefer-tag-over-role': withDefaultOption('error'), + 'jsx-a11y/role-has-required-aria-props': withDefaultOption('error'), + 'jsx-a11y/role-supports-aria-props': withDefaultOption('error'), + 'jsx-a11y/scope': withDefaultOption('error'), + 'jsx-a11y/tabindex-no-positive': withDefaultOption('error'), // deprecated 'jsx-a11y/accessible-emoji': 0, diff --git a/packages/eslint-configs/src/rules/eslint-playwright-rules.mts b/packages/eslint-configs/src/rules/eslint-playwright-rules.mts index b2a6ea2aa2..3aa6e35d6c 100644 --- a/packages/eslint-configs/src/rules/eslint-playwright-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-playwright-rules.mts @@ -1,15 +1,16 @@ import { type EslintPlaywrightRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintPlaywrightRules: EslintPlaywrightRules = { /* vitest と共通のルール（設定値をなるべく合わせる） */ - 'playwright/expect-expect': 'error', + 'playwright/expect-expect': withDefaultOption('error'), 'playwright/max-expects': 'off', - 'playwright/max-nested-describe': 'error', + 'playwright/max-nested-describe': withDefaultOption('error'), 'playwright/no-commented-out-tests': 'off', 'playwright/no-conditional-expect': 'error', 'playwright/no-conditional-in-test': 'off', 'playwright/no-duplicate-hooks': 'error', - 'playwright/no-hooks': 'error', + 'playwright/no-hooks': withDefaultOption('error'), 'playwright/no-restricted-matchers': [ 'error', { @@ -30,12 +31,12 @@ export const eslintPlaywrightRules: EslintPlaywrightRules = { 'playwright/require-to-throw-message': 'error', 'playwright/require-top-level-describe': 'off', 'playwright/valid-describe-callback': 'error', - 'playwright/valid-expect': 'error', + 'playwright/valid-expect': withDefaultOption('error'), 'playwright/valid-title': 'off', /* eslint-plugin-playwright 独自ルール */ - 'playwright/missing-playwright-await': 'error', + 'playwright/missing-playwright-await': withDefaultOption('error'), 'playwright/no-element-handle': 'error', 'playwright/no-eval': 'error', 'playwright/no-focused-test': 'error', @@ -45,17 +46,17 @@ export const eslintPlaywrightRules: EslintPlaywrightRules = { 'playwright/no-networkidle': 'error', 'playwright/no-nth-methods': 'off', 'playwright/no-page-pause': 'error', - 'playwright/no-raw-locators': 'error', - 'playwright/no-skipped-test': 'error', - 'playwright/no-slowed-test': 'error', + 'playwright/no-raw-locators': withDefaultOption('error'), + 'playwright/no-skipped-test': withDefaultOption('error'), + 'playwright/no-slowed-test': withDefaultOption('error'), 'playwright/no-unsafe-references': 'error', 'playwright/no-useless-await': 'error', 'playwright/no-useless-not': 'error', 'playwright/no-wait-for-selector': 'error', 'playwright/no-wait-for-timeout': 'error', 'playwright/prefer-locator': 'error', - 'playwright/prefer-lowercase-title': 'error', - 'playwright/prefer-native-locators': 'error', + 'playwright/prefer-lowercase-title': withDefaultOption('error'), + 'playwright/prefer-native-locators': withDefaultOption('error'), 'playwright/prefer-to-have-count': 'error', 'playwright/prefer-web-first-assertions': 'error', 'playwright/require-soft-assertions': 'error', diff --git a/packages/eslint-configs/src/rules/eslint-plugin-rules.mts b/packages/eslint-configs/src/rules/eslint-plugin-rules.mts index b79014ab9a..1bc23d35af 100644 --- a/packages/eslint-configs/src/rules/eslint-plugin-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-plugin-rules.mts @@ -1,16 +1,17 @@ import { type EslintPluginRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintPluginRules: EslintPluginRules = { - 'eslint-plugin/consistent-output': 'error', + 'eslint-plugin/consistent-output': withDefaultOption('error'), 'eslint-plugin/fixer-return': 'error', - 'eslint-plugin/meta-property-ordering': 'error', + 'eslint-plugin/meta-property-ordering': withDefaultOption('error'), 'eslint-plugin/no-deprecated-context-methods': 'error', 'eslint-plugin/no-deprecated-report-api': 'error', 'eslint-plugin/no-identical-tests': 'error', 'eslint-plugin/no-missing-message-ids': 'error', 'eslint-plugin/no-missing-placeholders': 'error', 'eslint-plugin/no-only-tests': 'error', - 'eslint-plugin/no-property-in-node': 'error', + 'eslint-plugin/no-property-in-node': withDefaultOption('error'), 'eslint-plugin/no-unused-message-ids': 'error', 'eslint-plugin/no-unused-placeholders': 'error', 'eslint-plugin/no-useless-token-range': 'error', @@ -19,17 +20,17 @@ export const eslintPluginRules: EslintPluginRules = { 'eslint-plugin/prefer-output-null': 'error', 'eslint-plugin/prefer-placeholders': 'error', 'eslint-plugin/prefer-replace-text': 'error', - 'eslint-plugin/report-message-format': 'error', - 'eslint-plugin/require-meta-docs-description': 'error', - 'eslint-plugin/require-meta-docs-recommended': 'error', - 'eslint-plugin/require-meta-docs-url': 'error', - 'eslint-plugin/require-meta-fixable': 'error', + 'eslint-plugin/report-message-format': withDefaultOption('error'), + 'eslint-plugin/require-meta-docs-description': withDefaultOption('error'), + 'eslint-plugin/require-meta-docs-recommended': withDefaultOption('error'), + 'eslint-plugin/require-meta-docs-url': withDefaultOption('error'), + 'eslint-plugin/require-meta-fixable': withDefaultOption('error'), 'eslint-plugin/require-meta-has-suggestions': 'error', 'eslint-plugin/require-meta-schema-description': 'error', - 'eslint-plugin/require-meta-schema': 'error', + 'eslint-plugin/require-meta-schema': withDefaultOption('error'), 'eslint-plugin/require-meta-type': 'error', - 'eslint-plugin/test-case-property-ordering': 'error', - 'eslint-plugin/test-case-shorthand-strings': 'error', + 'eslint-plugin/test-case-property-ordering': withDefaultOption('error'), + 'eslint-plugin/test-case-shorthand-strings': withDefaultOption('error'), 'eslint-plugin/no-meta-schema-default': 'error', 'eslint-plugin/require-meta-default-options': 'error', } as const; diff --git a/packages/eslint-configs/src/rules/eslint-promise-rules.mts b/packages/eslint-configs/src/rules/eslint-promise-rules.mts index 4443ea9652..dcf1bb97c3 100644 --- a/packages/eslint-configs/src/rules/eslint-promise-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-promise-rules.mts @@ -1,9 +1,10 @@ import { type EslintPromiseRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintPromiseRules: EslintPromiseRules = { 'promise/catch-or-return': ['error', { allowFinally: true }], - 'promise/no-return-wrap': 'error', - 'promise/param-names': 'error', + 'promise/no-return-wrap': withDefaultOption('error'), + 'promise/param-names': withDefaultOption('error'), 'promise/always-return': 'off', 'promise/no-native': 'off', 'promise/no-nesting': 'error', @@ -17,10 +18,10 @@ export const eslintPromiseRules: EslintPromiseRules = { 'promise/avoid-new': 'off', 'promise/no-new-statics': 'error', 'promise/no-return-in-finally': 'error', - 'promise/valid-params': 'error', + 'promise/valid-params': withDefaultOption('error'), 'promise/prefer-await-to-then': 'off', 'promise/prefer-await-to-callbacks': 'off', 'promise/no-multiple-resolved': 'error', - 'promise/spec-only': 'error', + 'promise/spec-only': withDefaultOption('error'), 'promise/prefer-catch': 'error', } as const; diff --git a/packages/eslint-configs/src/rules/eslint-react-hooks-rules.mts b/packages/eslint-configs/src/rules/eslint-react-hooks-rules.mts index 8320230701..5cdab4e466 100644 --- a/packages/eslint-configs/src/rules/eslint-react-hooks-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-react-hooks-rules.mts @@ -1,6 +1,7 @@ import { type EslintReactHooksRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintReactHooksRules: EslintReactHooksRules = { 'react-hooks/rules-of-hooks': 'error', - 'react-hooks/exhaustive-deps': 'error', + 'react-hooks/exhaustive-deps': withDefaultOption('error'), } as const; diff --git a/packages/eslint-configs/src/rules/eslint-react-refresh-rules.mts b/packages/eslint-configs/src/rules/eslint-react-refresh-rules.mts index 7bf4d04c69..13078e0cc6 100644 --- a/packages/eslint-configs/src/rules/eslint-react-refresh-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-react-refresh-rules.mts @@ -1,5 +1,6 @@ import { type EslintReactRefreshRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintReactRefreshRules: EslintReactRefreshRules = { - 'react-refresh/only-export-components': 'error', + 'react-refresh/only-export-components': withDefaultOption('error'), } as const; diff --git a/packages/eslint-configs/src/rules/eslint-react-rules.mts b/packages/eslint-configs/src/rules/eslint-react-rules.mts index c149e839fd..461c50c501 100644 --- a/packages/eslint-configs/src/rules/eslint-react-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-react-rules.mts @@ -1,4 +1,5 @@ import { type EslintReactRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintReactRules: EslintReactRules = { /** @@ -22,19 +23,19 @@ export const eslintReactRules: EslintReactRules = { 'react/jsx-tag-spacing': 'off', 'react/jsx-wrap-multilines': 'off', - 'react/boolean-prop-naming': 'error', - 'react/button-has-type': 'error', - 'react/default-props-match-prop-types': 'error', + 'react/boolean-prop-naming': withDefaultOption('error'), + 'react/button-has-type': withDefaultOption('error'), + 'react/default-props-match-prop-types': withDefaultOption('error'), /** Props を展開して使うかどうかを統一する。 */ - 'react/destructuring-assignment': 'error', + 'react/destructuring-assignment': withDefaultOption('error'), - 'react/display-name': 'error', + 'react/display-name': withDefaultOption('error'), 'react/forbid-component-props': ['error', { forbid: ['className'] }], // modified - 'react/forbid-dom-props': 'error', - 'react/forbid-elements': 'error', - 'react/forbid-foreign-prop-types': 'error', - 'react/forbid-prop-types': 'error', + 'react/forbid-dom-props': withDefaultOption('error'), + 'react/forbid-elements': withDefaultOption('error'), + 'react/forbid-foreign-prop-types': withDefaultOption('error'), + 'react/forbid-prop-types': withDefaultOption('error'), 'react/function-component-definition': [ 'error', { unnamedComponents: 'arrow-function', namedComponents: 'arrow-function' }, @@ -47,32 +48,32 @@ export const eslintReactRules: EslintReactRules = { /** ファイル名の統一 */ 'react/jsx-filename-extension': ['error', { extensions: ['.tsx'] }], // modified - 'react/jsx-fragments': 'error', + 'react/jsx-fragments': withDefaultOption('error'), 'react/jsx-handler-names': 'off', // disabled - 'react/jsx-key': 'error', + 'react/jsx-key': withDefaultOption('error'), 'react/jsx-max-depth': 'off', // disabled /** JSXに直接コールバック関数を書くのを禁止する。 修正方法： React.useCallback を使うようにする。 */ - 'react/jsx-no-bind': 'error', + 'react/jsx-no-bind': withDefaultOption('error'), 'react/jsx-no-comment-textnodes': 'error', 'react/jsx-no-constructed-context-values': 'error', - 'react/jsx-no-duplicate-props': 'error', + 'react/jsx-no-duplicate-props': withDefaultOption('error'), /** * JSXに文字列を直接書くのを避け `
    {"aaa"}
    ` のように書くことを強制する。 変数に `{}` * を付け忘れるミスに気づきやすくなったり syntax highlighting で読みやすくなるなどのメリットがある。 */ - 'react/jsx-no-literals': 'error', + 'react/jsx-no-literals': withDefaultOption('error'), - 'react/jsx-no-script-url': 'error', - 'react/jsx-no-target-blank': 'error', - 'react/jsx-no-undef': 'error', + 'react/jsx-no-script-url': withDefaultOption('error'), + 'react/jsx-no-target-blank': withDefaultOption('error'), + 'react/jsx-no-undef': withDefaultOption('error'), 'react/jsx-no-useless-fragment': ['error', { allowExpressions: true }], - 'react/jsx-pascal-case': 'error', + 'react/jsx-pascal-case': withDefaultOption('error'), /** `{...props}` 形式でpropsを渡すと props の過不足のチェックが甘くなるため */ - 'react/jsx-props-no-spreading': 'error', // modified + 'react/jsx-props-no-spreading': withDefaultOption('error'), // modified 'react/jsx-sort-props': [ 'error', @@ -88,15 +89,15 @@ export const eslintReactRules: EslintReactRules = { 'react/no-adjacent-inline-elements': 'error', 'react/no-array-index-key': 'error', // modified 'react/no-arrow-function-lifecycle': 'error', - 'react/no-children-prop': 'error', + 'react/no-children-prop': withDefaultOption('error'), 'react/no-danger-with-children': 'error', - 'react/no-danger': 'error', + 'react/no-danger': withDefaultOption('error'), 'react/no-deprecated': 'error', - 'react/no-did-mount-set-state': 'error', - 'react/no-did-update-set-state': 'error', + 'react/no-did-mount-set-state': withDefaultOption('error'), + 'react/no-did-update-set-state': withDefaultOption('error'), 'react/no-direct-mutation-state': 'error', 'react/no-find-dom-node': 'error', - 'react/no-invalid-html-attribute': 'error', + 'react/no-invalid-html-attribute': withDefaultOption('error'), 'react/no-is-mounted': 'error', 'react/no-multi-comp': [ 'error', @@ -108,40 +109,40 @@ export const eslintReactRules: EslintReactRules = { 'react/no-redundant-should-component-update': 'error', 'react/no-render-return-value': 'error', 'react/no-set-state': 'error', - 'react/no-string-refs': 'error', + 'react/no-string-refs': withDefaultOption('error'), 'react/no-this-in-sfc': 'error', 'react/no-typos': 'error', - 'react/no-unescaped-entities': 'error', + 'react/no-unescaped-entities': withDefaultOption('error'), // @emotion/react の css prop を使用するため 'react/no-unknown-property': ['error', { ignore: ['css'] }], - 'react/no-unsafe': 'error', + 'react/no-unsafe': withDefaultOption('error'), 'react/no-object-type-as-default-prop': 'error', - 'react/no-unstable-nested-components': 'error', + 'react/no-unstable-nested-components': withDefaultOption('error'), 'react/no-unused-class-component-methods': 'error', - 'react/no-unused-prop-types': 'error', + 'react/no-unused-prop-types': withDefaultOption('error'), 'react/no-unused-state': 'error', - 'react/no-will-update-set-state': 'error', - 'react/prefer-es6-class': 'error', + 'react/no-will-update-set-state': withDefaultOption('error'), + 'react/prefer-es6-class': withDefaultOption('error'), 'react/prefer-exact-props': 'error', 'react/prefer-read-only-props': 'error', - 'react/prefer-stateless-function': 'error', + 'react/prefer-stateless-function': withDefaultOption('error'), /** TypeScript では不要 */ 'react/prop-types': 'off', 'react/react-in-jsx-scope': 'off', // disabled - 'react/require-default-props': 'error', - 'react/require-optimization': 'error', + 'react/require-default-props': withDefaultOption('error'), + 'react/require-optimization': withDefaultOption('error'), 'react/require-render-return': 'error', - 'react/self-closing-comp': 'error', - 'react/sort-comp': 'error', - 'react/sort-default-props': 'error', - 'react/sort-prop-types': 'error', - 'react/state-in-constructor': 'error', - 'react/static-property-placement': 'error', - 'react/style-prop-object': 'error', + 'react/self-closing-comp': withDefaultOption('error'), + 'react/sort-comp': withDefaultOption('error'), + 'react/sort-default-props': withDefaultOption('error'), + 'react/sort-prop-types': withDefaultOption('error'), + 'react/state-in-constructor': withDefaultOption('error'), + 'react/static-property-placement': withDefaultOption('error'), + 'react/style-prop-object': withDefaultOption('error'), 'react/void-dom-elements-no-children': 'error', 'react/jsx-no-leaked-render': [ 'error', @@ -149,7 +150,7 @@ export const eslintReactRules: EslintReactRules = { validStrategies: ['ternary'], }, ], - 'react/checked-requires-onchange-or-readonly': 'error', + 'react/checked-requires-onchange-or-readonly': withDefaultOption('error'), 'react/jsx-props-no-spread-multi': 'error', 'react/forward-ref-uses-ref': 'error', diff --git a/packages/eslint-configs/src/rules/eslint-rules.mts b/packages/eslint-configs/src/rules/eslint-rules.mts index 3be7120eb0..fc745938a6 100644 --- a/packages/eslint-configs/src/rules/eslint-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-rules.mts @@ -1,4 +1,5 @@ import { type EslintRules, type EslintRulesOption } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const restrictedSyntax = [ { @@ -148,7 +149,7 @@ export const eslintRules: EslintRules = { 'no-unreachable': 'off', // ts(7027) 'no-unsafe-negation': 'off', // ts(2365) & ts(2360) & ts(2358) 'no-var': 'error', // ts transpiles let/const to var, so no need for vars any more - 'prefer-const': 'error', // ts provides better types with const + 'prefer-const': withDefaultOption('error'), // ts provides better types with const 'prefer-rest-params': 'error', // ts provides better types with rest args over arguments 'prefer-spread': 'error', // ts transpiles spread to apply, so no need for manual apply 'valid-typeof': 'off', // ts(2367) @@ -178,7 +179,7 @@ export const eslintRules: EslintRules = { 'consistent-return': 'off', // customized - 'accessor-pairs': 'error', + 'accessor-pairs': withDefaultOption('error'), // When there is no default case for a switch statement, there is a false positive that reports an error without considering type information. 'array-callback-return': 'off', @@ -188,19 +189,19 @@ export const eslintRules: EslintRules = { camelcase: 'off', // disabled 'capitalized-comments': 'off', // disabled complexity: 'off', // disabled - 'consistent-this': 'error', + 'consistent-this': withDefaultOption('error'), 'default-case-last': 'error', 'default-case': 'off', // disabled eqeqeq: ['error', 'always', { null: 'ignore' }], // modified 'for-direction': 'error', - 'func-name-matching': 'error', - 'func-names': 'error', + 'func-name-matching': withDefaultOption('error'), + 'func-names': withDefaultOption('error'), 'func-style': 'off', // 関数オーバーロードで偽陽性が出る - 'grouped-accessor-pairs': 'error', + 'grouped-accessor-pairs': withDefaultOption('error'), 'guard-for-in': 'error', - 'id-denylist': 'error', + 'id-denylist': withDefaultOption('error'), 'id-length': 'off', // disabled - 'id-match': 'error', + 'id-match': withDefaultOption('error'), 'logical-assignment-operators': [ 'error', 'always', @@ -210,7 +211,7 @@ export const eslintRules: EslintRules = { 'max-depth': 'off', // disabled 'max-lines-per-function': 'off', // disabled 'max-lines': 'off', // disabled - 'max-nested-callbacks': 'error', + 'max-nested-callbacks': withDefaultOption('error'), 'max-params': 'off', // disabled 'max-statements': 'off', // disabled 'new-cap': 'off', // disabled @@ -222,10 +223,10 @@ export const eslintRules: EslintRules = { 'no-case-declarations': 'error', 'no-class-assign': 'error', 'no-compare-neg-zero': 'error', - 'no-cond-assign': 'error', + 'no-cond-assign': withDefaultOption('error'), 'no-console': 'off', // disabled 'no-constant-binary-expression': 'error', - 'no-constant-condition': 'error', + 'no-constant-condition': withDefaultOption('error'), 'no-constructor-return': 'error', 'no-continue': 'off', // disabled 'no-control-regex': 'error', @@ -236,13 +237,13 @@ export const eslintRules: EslintRules = { 'no-duplicate-case': 'error', 'no-else-return': 'off', // disabled 'no-empty-character-class': 'error', - 'no-empty-pattern': 'error', + 'no-empty-pattern': withDefaultOption('error'), 'no-empty-static-block': 'error', - 'no-empty': 'error', + 'no-empty': withDefaultOption('error'), 'no-eq-null': 'off', // eqeqeqでnull許容するならoff - 'no-eval': 'error', + 'no-eval': withDefaultOption('error'), 'no-ex-assign': 'error', - 'no-extend-native': 'error', + 'no-extend-native': withDefaultOption('error'), 'no-extra-bind': 'error', 'no-extra-boolean-cast': [ 'error', @@ -251,8 +252,8 @@ export const eslintRules: EslintRules = { }, ], 'no-extra-label': 'error', - 'no-fallthrough': 'error', - 'no-global-assign': 'error', + 'no-fallthrough': withDefaultOption('error'), + 'no-global-assign': withDefaultOption('error'), 'no-implicit-coercion': [ 'error', { @@ -263,18 +264,18 @@ export const eslintRules: EslintRules = { string: true, }, ], - 'no-implicit-globals': 'error', + 'no-implicit-globals': withDefaultOption('error'), 'no-inline-comments': 'off', // disabled - 'no-inner-declarations': 'error', - 'no-invalid-regexp': 'error', - 'no-irregular-whitespace': 'error', + 'no-inner-declarations': withDefaultOption('error'), + 'no-invalid-regexp': withDefaultOption('error'), + 'no-irregular-whitespace': withDefaultOption('error'), 'no-iterator': 'error', 'no-label-var': 'error', - 'no-labels': 'error', + 'no-labels': withDefaultOption('error'), 'no-lone-blocks': 'off', // disabled 'no-lonely-if': 'off', // disabled - 'no-misleading-character-class': 'error', - 'no-multi-assign': 'error', + 'no-misleading-character-class': withDefaultOption('error'), + 'no-multi-assign': withDefaultOption('error'), 'no-multi-str': 'error', 'no-negated-condition': 'off', // disabled 'no-nested-ternary': 'off', // unicorn/no-nested-ternary @@ -286,7 +287,7 @@ export const eslintRules: EslintRules = { 'no-object-constructor': 'error', 'no-octal-escape': 'error', 'no-octal': 'error', - 'no-param-reassign': 'error', + 'no-param-reassign': withDefaultOption('error'), /** `++x` や `x++` という式の値を使用しているコードは可読性が落ちやすいため警告を出す */ 'no-plusplus': [ @@ -296,13 +297,13 @@ export const eslintRules: EslintRules = { }, ], - 'no-promise-executor-return': 'error', + 'no-promise-executor-return': withDefaultOption('error'), 'no-proto': 'error', 'no-prototype-builtins': 'error', 'no-regex-spaces': 'error', - 'no-restricted-exports': 'error', + 'no-restricted-exports': withDefaultOption('error'), 'no-restricted-globals': ['error', ...restrictedGlobals], - 'no-restricted-properties': 'error', + 'no-restricted-properties': withDefaultOption('error'), /** * 他ルールで実現しづらい禁止したい構文をここに書く。 以下のAST checker を用いて selector をどう書くべきか調べることができる。 @@ -312,11 +313,11 @@ export const eslintRules: EslintRules = { */ 'no-restricted-syntax': ['error', ...restrictedSyntax], - 'no-return-assign': 'error', + 'no-return-assign': withDefaultOption('error'), 'no-script-url': 'error', - 'no-self-assign': 'error', + 'no-self-assign': withDefaultOption('error'), 'no-self-compare': 'error', - 'no-sequences': 'error', + 'no-sequences': withDefaultOption('error'), 'no-shadow-restricted-names': 'error', 'no-sparse-arrays': 'error', 'no-template-curly-in-string': 'error', @@ -325,34 +326,34 @@ export const eslintRules: EslintRules = { 'no-undefined': 'off', // disabled 'no-underscore-dangle': 'off', // disabled 'no-unmodified-loop-condition': 'error', - 'no-unneeded-ternary': 'error', - 'no-unreachable-loop': 'error', + 'no-unneeded-ternary': withDefaultOption('error'), + 'no-unreachable-loop': withDefaultOption('error'), 'no-unsafe-finally': 'error', - 'no-unsafe-optional-chaining': 'error', + 'no-unsafe-optional-chaining': withDefaultOption('error'), 'no-unused-labels': 'error', 'no-unused-private-class-members': 'error', 'no-useless-backreference': 'error', 'no-useless-call': 'error', 'no-useless-catch': 'error', - 'no-useless-computed-key': 'error', + 'no-useless-computed-key': withDefaultOption('error'), 'no-useless-concat': 'error', 'no-useless-escape': 'error', - 'no-useless-rename': 'error', + 'no-useless-rename': withDefaultOption('error'), 'no-useless-return': 'error', - 'no-void': 'error', + 'no-void': withDefaultOption('error'), 'no-warning-comments': 'off', // disabled 'no-with': 'error', - 'object-shorthand': 'error', + 'object-shorthand': withDefaultOption('error'), 'one-var': 'off', // disabled - 'operator-assignment': 'error', - 'prefer-arrow-callback': 'error', + 'operator-assignment': withDefaultOption('error'), + 'prefer-arrow-callback': withDefaultOption('error'), 'prefer-destructuring': 'off', // disabled 'prefer-exponentiation-operator': 'error', 'prefer-named-capture-group': 'off', // disabled 'prefer-numeric-literals': 'error', 'prefer-object-has-own': 'error', 'prefer-object-spread': 'error', - 'prefer-regex-literals': 'error', + 'prefer-regex-literals': withDefaultOption('error'), /** * `+` の曖昧性回避のため使用。 restrict-plus-operands で bigint, number, string @@ -364,16 +365,16 @@ export const eslintRules: EslintRules = { */ 'prefer-template': 'error', - radix: 'error', - 'require-atomic-updates': 'error', - 'require-unicode-regexp': 'error', + radix: withDefaultOption('error'), + 'require-atomic-updates': withDefaultOption('error'), + 'require-unicode-regexp': withDefaultOption('error'), 'require-yield': 'error', 'sort-imports': 'off', // disabled 'sort-keys': 'off', // disabled 'sort-vars': 'off', // disabled - strict: 'error', + strict: withDefaultOption('error'), 'symbol-description': 'off', // disabled - 'use-isnan': 'error', + 'use-isnan': withDefaultOption('error'), 'vars-on-top': 'error', yoda: 'off', // disabled diff --git a/packages/eslint-configs/src/rules/eslint-testing-library-rules.mts b/packages/eslint-configs/src/rules/eslint-testing-library-rules.mts index 0daa15b126..f079cf75cc 100644 --- a/packages/eslint-configs/src/rules/eslint-testing-library-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-testing-library-rules.mts @@ -1,4 +1,5 @@ import { type EslintTestingLibraryRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintTestingLibraryRules: EslintTestingLibraryRules = { 'testing-library/await-async-events': ['error', { eventModule: 'userEvent' }], @@ -10,19 +11,19 @@ export const eslintTestingLibraryRules: EslintTestingLibraryRules = { ], 'testing-library/no-await-sync-queries': 'error', 'testing-library/no-container': 'error', - 'testing-library/no-debugging-utils': 'warn', + 'testing-library/no-debugging-utils': withDefaultOption('warn'), 'testing-library/no-dom-import': ['error', 'react'], 'testing-library/no-global-regexp-flag-in-query': 'error', 'testing-library/no-manual-cleanup': 'error', - 'testing-library/no-node-access': 'error', + 'testing-library/no-node-access': withDefaultOption('error'), 'testing-library/no-promise-in-fire-event': 'error', - 'testing-library/no-render-in-lifecycle': 'error', - 'testing-library/no-unnecessary-act': 'error', + 'testing-library/no-render-in-lifecycle': withDefaultOption('error'), + 'testing-library/no-unnecessary-act': withDefaultOption('error'), 'testing-library/no-wait-for-multiple-assertions': 'error', 'testing-library/no-wait-for-side-effects': 'error', 'testing-library/no-wait-for-snapshot': 'error', 'testing-library/prefer-find-by': 'error', - 'testing-library/prefer-presence-queries': 'error', + 'testing-library/prefer-presence-queries': withDefaultOption('error'), 'testing-library/prefer-query-by-disappearance': 'error', 'testing-library/prefer-screen-queries': 'error', 'testing-library/render-result-naming-convention': 'error', diff --git a/packages/eslint-configs/src/rules/eslint-unicorn-rules.mts b/packages/eslint-configs/src/rules/eslint-unicorn-rules.mts index 20fa4761ff..2af7a3b843 100644 --- a/packages/eslint-configs/src/rules/eslint-unicorn-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-unicorn-rules.mts @@ -1,4 +1,5 @@ import { type EslintUnicornRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintUnicornRules: EslintUnicornRules = { /** @@ -10,17 +11,17 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/no-nested-ternary': 'off', 'unicorn/number-literal-case': 'off', - 'unicorn/better-regex': 'error', - 'unicorn/catch-error-name': 'error', + 'unicorn/better-regex': withDefaultOption('error'), + 'unicorn/catch-error-name': withDefaultOption('error'), /** Props を展開して使うかどうかを統一する。 */ 'unicorn/consistent-destructuring': 'error', - 'unicorn/consistent-function-scoping': 'error', + 'unicorn/consistent-function-scoping': withDefaultOption('error'), 'unicorn/custom-error-definition': 'off', 'unicorn/error-message': 'error', 'unicorn/escape-case': 'error', - 'unicorn/expiring-todo-comments': 'error', + 'unicorn/expiring-todo-comments': withDefaultOption('error'), 'unicorn/explicit-length-check': 'off', /** ファイル名の統一 */ @@ -60,7 +61,7 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/no-array-callback-reference': 'off', 'unicorn/no-array-for-each': 'error', 'unicorn/no-array-method-this-argument': 'off', // not compatible with my Arr.map utility - 'unicorn/no-array-push-push': 'error', + 'unicorn/no-array-push-push': withDefaultOption('error'), 'unicorn/no-array-reduce': 'off', 'unicorn/no-await-expression-member': 'error', 'unicorn/no-console-spaces': 'off', // turned off to enable aligning output @@ -81,7 +82,7 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/no-static-only-class': 'error', 'unicorn/no-thenable': 'error', 'unicorn/no-this-assignment': 'error', - 'unicorn/no-typeof-undefined': 'error', + 'unicorn/no-typeof-undefined': withDefaultOption('error'), 'unicorn/no-unnecessary-await': 'error', 'unicorn/no-unreadable-array-destructuring': 'error', 'unicorn/no-unsafe-regex': 0, // dup of "security/detect-unsafe-regex" @@ -92,10 +93,10 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/no-useless-spread': 'error', 'unicorn/no-useless-undefined': 'off', // this conflicts with @typescript-eslint/init-declarations 'unicorn/no-zero-fractions': 'error', - 'unicorn/numeric-separators-style': 'error', - 'unicorn/prefer-add-event-listener': 'error', - 'unicorn/prefer-array-find': 'error', - 'unicorn/prefer-array-flat': 'error', + 'unicorn/numeric-separators-style': withDefaultOption('error'), + 'unicorn/prefer-add-event-listener': withDefaultOption('error'), + 'unicorn/prefer-array-find': withDefaultOption('error'), + 'unicorn/prefer-array-flat': withDefaultOption('error'), 'unicorn/prefer-array-flat-map': 'error', 'unicorn/prefer-array-index-of': 'error', 'unicorn/prefer-array-some': 'error', @@ -113,7 +114,7 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/prefer-dom-node-dataset': 'error', 'unicorn/prefer-dom-node-remove': 'error', 'unicorn/prefer-dom-node-text-content': 'error', - 'unicorn/prefer-export-from': 'error', + 'unicorn/prefer-export-from': withDefaultOption('error'), 'unicorn/prefer-includes': 'error', 'unicorn/prefer-json-parse-buffer': 'off', 'unicorn/prefer-keyboard-event-key': 'error', @@ -122,8 +123,8 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/prefer-module': 'error', 'unicorn/prefer-negative-index': 'error', 'unicorn/prefer-node-protocol': 'off', // TODO: enable this - 'unicorn/prefer-number-properties': 'error', - 'unicorn/prefer-object-from-entries': 'error', + 'unicorn/prefer-number-properties': withDefaultOption('error'), + 'unicorn/prefer-object-from-entries': withDefaultOption('error'), 'unicorn/prefer-optional-catch-binding': 'error', 'unicorn/prefer-prototype-methods': 'error', 'unicorn/prefer-query-selector': 'error', @@ -146,15 +147,15 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/prefer-top-level-await': 'off', 'unicorn/prefer-type-error': 'error', 'unicorn/prevent-abbreviations': 'off', - 'unicorn/relative-url-style': 'error', + 'unicorn/relative-url-style': withDefaultOption('error'), 'unicorn/require-array-join-separator': 'error', 'unicorn/require-number-to-fixed-digits-argument': 'error', // Turned off because we can't distinguish `widow.postMessage` and `{Worker,MessagePort,Client,BroadcastChannel}#postMessage()` // See #1396 'unicorn/require-post-message-target-origin': 'off', - 'unicorn/string-content': 'error', + 'unicorn/string-content': withDefaultOption('error'), 'unicorn/switch-case-braces': 'off', // TODO: Enable this - 'unicorn/template-indent': 'error', + 'unicorn/template-indent': withDefaultOption('error'), 'unicorn/text-encoding-identifier-case': 'error', 'unicorn/throw-new-error': 'error', 'unicorn/no-unreadable-iife': 'error', @@ -174,7 +175,7 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/prefer-event-target': 'error', 'unicorn/prefer-logical-operator-over-ternary': 'error', 'unicorn/prefer-blob-reading-methods': 'error', - 'unicorn/no-unnecessary-polyfills': 'error', + 'unicorn/no-unnecessary-polyfills': withDefaultOption('error'), 'unicorn/no-anonymous-default-export': 'error', 'unicorn/no-await-in-promise-methods': 'error', 'unicorn/no-single-promise-in-promise-methods': 'error', @@ -182,7 +183,7 @@ export const eslintUnicornRules: EslintUnicornRules = { 'unicorn/no-invalid-fetch-options': 'error', 'unicorn/no-magic-array-flat-depth': 'error', 'unicorn/prefer-string-raw': 'error', - 'unicorn/prefer-structured-clone': 'error', + 'unicorn/prefer-structured-clone': withDefaultOption('error'), 'unicorn/no-length-as-slice-end': 'error', 'unicorn/no-negation-in-equality-check': 'error', 'unicorn/consistent-existence-index-check': 'error', diff --git a/packages/eslint-configs/src/rules/eslint-vitest-rules.mts b/packages/eslint-configs/src/rules/eslint-vitest-rules.mts index b2efcde617..0fcc5012b8 100644 --- a/packages/eslint-configs/src/rules/eslint-vitest-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-vitest-rules.mts @@ -1,15 +1,16 @@ import { type EslintVitestRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const eslintVitestRules: EslintVitestRules = { /* jest, playwright と共通のルール（設定値をなるべく合わせる） */ - 'vitest/expect-expect': 'error', + 'vitest/expect-expect': withDefaultOption('error'), 'vitest/max-expects': 'off', - 'vitest/max-nested-describe': 'error', + 'vitest/max-nested-describe': withDefaultOption('error'), 'vitest/no-commented-out-tests': 'off', 'vitest/no-conditional-expect': 'error', 'vitest/no-conditional-in-test': 'off', 'vitest/no-duplicate-hooks': 'error', - 'vitest/no-hooks': 'error', + 'vitest/no-hooks': withDefaultOption('error'), 'vitest/no-restricted-matchers': [ 'error', { @@ -17,7 +18,7 @@ export const eslintVitestRules: EslintVitestRules = { toBeFalsy: 'Use `.toBe(false)` instead.', }, ], - 'vitest/no-standalone-expect': 'error', + 'vitest/no-standalone-expect': withDefaultOption('error'), 'vitest/prefer-comparison-matcher': 'error', 'vitest/prefer-equality-matcher': 'error', 'vitest/prefer-hooks-in-order': 'error', @@ -30,7 +31,7 @@ export const eslintVitestRules: EslintVitestRules = { 'vitest/require-to-throw-message': 'error', 'vitest/require-top-level-describe': 'off', 'vitest/valid-describe-callback': 'error', - 'vitest/valid-expect': 'error', + 'vitest/valid-expect': withDefaultOption('error'), 'vitest/valid-title': 'off', /* jest と共通のルール（設定値をなるべく合わせる） */ @@ -38,10 +39,10 @@ export const eslintVitestRules: EslintVitestRules = { 'vitest/consistent-test-it': ['error', { fn: 'test' }], 'vitest/no-alias-methods': 'error', 'vitest/no-disabled-tests': 'error', - 'vitest/no-focused-tests': 'error', + 'vitest/no-focused-tests': withDefaultOption('error'), 'vitest/no-identical-title': 'error', 'vitest/no-interpolation-in-snapshots': 'error', - 'vitest/no-large-snapshots': 'error', + 'vitest/no-large-snapshots': withDefaultOption('error'), 'vitest/no-mocks-import': 'error', 'vitest/no-restricted-vi-methods': [ 'error', @@ -58,7 +59,7 @@ export const eslintVitestRules: EslintVitestRules = { 'vitest/prefer-expect-resolves': 'error', 'vitest/prefer-lowercase-title': 'off', 'vitest/prefer-mock-promise-shorthand': 'error', - 'vitest/prefer-snapshot-hint': 'error', + 'vitest/prefer-snapshot-hint': withDefaultOption('error'), 'vitest/prefer-spy-on': 'error', 'vitest/prefer-todo': 'error', @@ -67,7 +68,7 @@ export const eslintVitestRules: EslintVitestRules = { // inline test を書けなくなるのでオフ 'vitest/no-conditional-tests': 'off', - 'vitest/consistent-test-filename': 'error', + 'vitest/consistent-test-filename': withDefaultOption('error'), 'vitest/no-import-node-test': 'error', // toBeFalsy() は toBe(false) より緩いのでこれらのルールは却下 diff --git a/packages/eslint-configs/src/rules/typescript-eslint-rules.mts b/packages/eslint-configs/src/rules/typescript-eslint-rules.mts index c976663997..e4bddd9caa 100644 --- a/packages/eslint-configs/src/rules/typescript-eslint-rules.mts +++ b/packages/eslint-configs/src/rules/typescript-eslint-rules.mts @@ -3,6 +3,7 @@ import { type TypeScriptEslintRules, type TypeScriptEslintRulesOption, } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; export const banTypes: TypeScriptEslintRulesOption['@typescript-eslint/no-restricted-types']['types'] = { @@ -56,6 +57,7 @@ export const restrictedImportsOption: RestrictedImportsOption = { }, ], } as const; + export const typescriptEslintRules: TypeScriptEslintRules = { '@typescript-eslint/adjacent-overload-signatures': 'error', '@typescript-eslint/array-type': [ @@ -66,7 +68,7 @@ export const typescriptEslintRules: TypeScriptEslintRules = { }, ], '@typescript-eslint/await-thenable': 'error', - '@typescript-eslint/ban-ts-comment': 'error', + '@typescript-eslint/ban-ts-comment': withDefaultOption('error'), '@typescript-eslint/ban-tslint-comment': 'error', '@typescript-eslint/no-restricted-types': [ 'error', @@ -74,8 +76,9 @@ export const typescriptEslintRules: TypeScriptEslintRules = { types: banTypes, }, ], - '@typescript-eslint/class-literal-property-style': 'error', - '@typescript-eslint/consistent-indexed-object-style': 'error', + '@typescript-eslint/class-literal-property-style': withDefaultOption('error'), + '@typescript-eslint/consistent-indexed-object-style': + withDefaultOption('error'), '@typescript-eslint/consistent-type-assertions': [ 'error', { @@ -124,39 +127,39 @@ export const typescriptEslintRules: TypeScriptEslintRules = { { accessibility: 'no-public' }, ], // modified '@typescript-eslint/explicit-module-boundary-types': 'off', // preferred to use explicit-function-return-type - '@typescript-eslint/init-declarations': 'error', + '@typescript-eslint/init-declarations': withDefaultOption('error'), '@typescript-eslint/member-ordering': 'off', // disabled /** * 関数メンバーをメソッド記法で書くと双変になり安全性が低くなるため * https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-function-parameters-bivariant */ - '@typescript-eslint/method-signature-style': 'error', + '@typescript-eslint/method-signature-style': withDefaultOption('error'), '@typescript-eslint/prefer-function-type': 'error', '@typescript-eslint/naming-convention': 'off', // disabled '@typescript-eslint/no-array-constructor': 'error', - '@typescript-eslint/no-base-to-string': 'error', + '@typescript-eslint/no-base-to-string': withDefaultOption('error'), '@typescript-eslint/no-confusing-non-null-assertion': 'error', - '@typescript-eslint/no-confusing-void-expression': 'error', + '@typescript-eslint/no-confusing-void-expression': withDefaultOption('error'), '@typescript-eslint/no-dupe-class-members': 'error', '@typescript-eslint/no-dynamic-delete': 'error', '@typescript-eslint/no-empty-function': 'off', // disabled - '@typescript-eslint/no-explicit-any': 'error', + '@typescript-eslint/no-explicit-any': withDefaultOption('error'), '@typescript-eslint/no-extra-non-null-assertion': 'error', - '@typescript-eslint/no-extraneous-class': 'error', - '@typescript-eslint/no-floating-promises': 'error', + '@typescript-eslint/no-extraneous-class': withDefaultOption('error'), + '@typescript-eslint/no-floating-promises': withDefaultOption('error'), '@typescript-eslint/no-for-in-array': 'error', '@typescript-eslint/no-implied-eval': 'error', /** 型を明示的に書きたい場合もあるためオフに */ '@typescript-eslint/no-inferrable-types': 'off', // disabled - '@typescript-eslint/no-invalid-this': 'error', - '@typescript-eslint/no-invalid-void-type': 'error', + '@typescript-eslint/no-invalid-this': withDefaultOption('error'), + '@typescript-eslint/no-invalid-void-type': withDefaultOption('error'), '@typescript-eslint/no-loop-func': 'error', '@typescript-eslint/no-magic-numbers': 'off', // disabled - '@typescript-eslint/no-meaningless-void-operator': 'error', + '@typescript-eslint/no-meaningless-void-operator': withDefaultOption('error'), '@typescript-eslint/no-misused-new': 'error', '@typescript-eslint/no-misused-promises': [ 'error', @@ -170,7 +173,7 @@ export const typescriptEslintRules: TypeScriptEslintRules = { '@typescript-eslint/no-non-null-assertion': 'error', '@typescript-eslint/no-redeclare': 'off', // disabled '@typescript-eslint/no-redundant-type-constituents': 'error', // modified - '@typescript-eslint/no-require-imports': 'error', + '@typescript-eslint/no-require-imports': withDefaultOption('error'), '@typescript-eslint/no-restricted-imports': [ // modified 'error', @@ -185,15 +188,17 @@ export const typescriptEslintRules: TypeScriptEslintRules = { ignoreFunctionTypeParameterNameValueShadow: false, }, ], // modified - '@typescript-eslint/no-this-alias': 'error', - '@typescript-eslint/no-unnecessary-boolean-literal-compare': 'error', + '@typescript-eslint/no-this-alias': withDefaultOption('error'), + '@typescript-eslint/no-unnecessary-boolean-literal-compare': + withDefaultOption('error'), '@typescript-eslint/no-unnecessary-condition': [ 'error', { allowConstantLoopConditions: true }, ], // modified '@typescript-eslint/no-unnecessary-qualifier': 'error', '@typescript-eslint/no-unnecessary-type-arguments': 'off', // disabled - '@typescript-eslint/no-unnecessary-type-assertion': 'error', + '@typescript-eslint/no-unnecessary-type-assertion': + withDefaultOption('error'), '@typescript-eslint/no-unnecessary-type-constraint': 'error', '@typescript-eslint/no-unsafe-argument': 'error', '@typescript-eslint/no-unsafe-assignment': 'error', @@ -201,7 +206,7 @@ export const typescriptEslintRules: TypeScriptEslintRules = { '@typescript-eslint/no-unsafe-declaration-merging': 'error', '@typescript-eslint/no-unsafe-member-access': 'error', '@typescript-eslint/no-unsafe-return': 'error', - '@typescript-eslint/no-unused-expressions': 'error', + '@typescript-eslint/no-unused-expressions': withDefaultOption('error'), '@typescript-eslint/no-unused-vars': [ 'error', { @@ -226,7 +231,7 @@ export const typescriptEslintRules: TypeScriptEslintRules = { '@typescript-eslint/prefer-for-of': 'error', '@typescript-eslint/prefer-includes': 'error', - '@typescript-eslint/prefer-literal-enum-member': 'error', + '@typescript-eslint/prefer-literal-enum-member': withDefaultOption('error'), '@typescript-eslint/prefer-namespace-keyword': 'error', '@typescript-eslint/prefer-nullish-coalescing': [ 'error', @@ -243,8 +248,8 @@ export const typescriptEslintRules: TypeScriptEslintRules = { }, }, ], - '@typescript-eslint/prefer-optional-chain': 'error', - '@typescript-eslint/prefer-readonly': 'error', + '@typescript-eslint/prefer-optional-chain': withDefaultOption('error'), + '@typescript-eslint/prefer-readonly': withDefaultOption('error'), '@typescript-eslint/prefer-readonly-parameter-types': [ 'error', { @@ -344,7 +349,8 @@ export const typescriptEslintRules: TypeScriptEslintRules = { '@typescript-eslint/prefer-reduce-type-parameter': 'error', '@typescript-eslint/prefer-regexp-exec': 'error', '@typescript-eslint/prefer-return-this-type': 'error', - '@typescript-eslint/prefer-string-starts-ends-with': 'error', + '@typescript-eslint/prefer-string-starts-ends-with': + withDefaultOption('error'), '@typescript-eslint/promise-function-async': 'off', // disabled /** `sort` はデフォルトで文字列としての比較を行うため、数値のソートを行おうとしたときに比較関数を忘れることを防ぐため使用。 */ @@ -387,7 +393,7 @@ export const typescriptEslintRules: TypeScriptEslintRules = { allowArray: false, }, ], // modified - '@typescript-eslint/return-await': 'error', + '@typescript-eslint/return-await': withDefaultOption('error'), /** * Boolean への暗黙のキャストを回避するために使用。 数値 `0`, `NaN` や 文字列 `""` が条件部に来たときに false @@ -415,23 +421,25 @@ export const typescriptEslintRules: TypeScriptEslintRules = { path: 'always', }, ], - '@typescript-eslint/typedef': 'error', - '@typescript-eslint/unbound-method': 'error', - '@typescript-eslint/unified-signatures': 'error', + '@typescript-eslint/typedef': withDefaultOption('error'), + '@typescript-eslint/unbound-method': withDefaultOption('error'), + '@typescript-eslint/unified-signatures': withDefaultOption('error'), - '@typescript-eslint/consistent-generic-constructors': 'error', + '@typescript-eslint/consistent-generic-constructors': + withDefaultOption('error'), '@typescript-eslint/no-duplicate-enum-values': 'error', - '@typescript-eslint/parameter-properties': 'error', + '@typescript-eslint/parameter-properties': withDefaultOption('error'), // This rule must be enabled when the --verbatimModuleSyntax compiler option is enabled '@typescript-eslint/no-import-type-side-effects': 'off', '@typescript-eslint/no-mixed-enums': 'error', - '@typescript-eslint/no-duplicate-type-constituents': 'error', + '@typescript-eslint/no-duplicate-type-constituents': + withDefaultOption('error'), '@typescript-eslint/no-unsafe-enum-comparison': 'error', - '@typescript-eslint/class-methods-use-this': 'error', + '@typescript-eslint/class-methods-use-this': withDefaultOption('error'), '@typescript-eslint/max-params': 'off', '@typescript-eslint/prefer-destructuring': 'off', @@ -454,7 +462,7 @@ export const typescriptEslintRules: TypeScriptEslintRules = { }, ], - '@typescript-eslint/no-empty-object-type': 'error', + '@typescript-eslint/no-empty-object-type': withDefaultOption('error'), '@typescript-eslint/no-unnecessary-parameter-property-assignment': 'error', '@typescript-eslint/no-unnecessary-template-expression': 'error', @@ -463,14 +471,14 @@ export const typescriptEslintRules: TypeScriptEslintRules = { '@typescript-eslint/no-unsafe-function-type': 'error', '@typescript-eslint/no-wrapper-object-types': 'error', - '@typescript-eslint/no-deprecated': 'error', + '@typescript-eslint/no-deprecated': withDefaultOption('error'), // total-functions/no-unsafe-type-assertion の方が厳格なチェックができるようなのでこちらはオフ '@typescript-eslint/no-unsafe-type-assertion': 'off', '@typescript-eslint/related-getter-setter-pairs': 'error', - '@typescript-eslint/no-misused-spread': 'error', + '@typescript-eslint/no-misused-spread': withDefaultOption('error'), // deprecated '@typescript-eslint/no-type-alias': 0, diff --git a/packages/eslint-configs/src/types/index.mts b/packages/eslint-configs/src/types/index.mts index 61f9507a51..d6a15460ed 100644 --- a/packages/eslint-configs/src/types/index.mts +++ b/packages/eslint-configs/src/types/index.mts @@ -1,3 +1,4 @@ export * from './flat-config.mjs'; +export * from './rule-severity-branded.mjs'; export * from './rules/index.mjs'; export * from './types.mjs'; diff --git a/packages/eslint-configs/src/types/rule-severity-branded.mts b/packages/eslint-configs/src/types/rule-severity-branded.mts new file mode 100644 index 0000000000..5964da5bdf --- /dev/null +++ b/packages/eslint-configs/src/types/rule-severity-branded.mts @@ -0,0 +1,19 @@ +import { type Linter } from 'eslint'; + +export type RuleSeverityWithDefaultOption = Linter.Severity; + +/** + * A simple wrapper function to make the existence of an option setting explicit + * in the config statement. This function casts `Linter.RuleSeverity` type value + * to `RuleSeverityWithDefaultOption` type. + */ +export const withDefaultOption = ( + severity: 'warn' | 'error', +): RuleSeverityWithDefaultOption => { + switch (severity) { + case 'warn': + return 1; + case 'error': + return 2; + } +}; diff --git a/packages/eslint-configs/src/types/rules/eslint-array-func-rules.mts b/packages/eslint-configs/src/types/rules/eslint-array-func-rules.mts index 0f22f7fc3a..ed18f1123c 100644 --- a/packages/eslint-configs/src/types/rules/eslint-array-func-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-array-func-rules.mts @@ -13,7 +13,7 @@ import { type Linter } from 'eslint'; * ``` */ namespace FromMap { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -29,7 +29,7 @@ namespace FromMap { * ``` */ namespace NoUnnecessaryThisArg { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -45,7 +45,7 @@ namespace NoUnnecessaryThisArg { * ``` */ namespace PreferArrayFrom { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -60,7 +60,7 @@ namespace PreferArrayFrom { * ``` */ namespace AvoidReverse { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -75,7 +75,7 @@ namespace AvoidReverse { * ``` */ namespace PreferFlatMap { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -90,7 +90,7 @@ namespace PreferFlatMap { * ``` */ namespace PreferFlat { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } export type EslintArrayFuncRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts b/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts index 8ed6e7f5bc..96adb69684 100644 --- a/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Disallow assigning return values of `cy` calls @@ -18,7 +22,7 @@ type SpreadOptionsIfIsArray = * ``` */ namespace NoAssigningReturnValues { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -63,8 +67,9 @@ namespace UnsafeToChainCommand { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -81,7 +86,7 @@ namespace UnsafeToChainCommand { * ``` */ namespace NoUnnecessaryWaiting { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -98,7 +103,7 @@ namespace NoUnnecessaryWaiting { * ``` */ namespace NoAsyncBefore { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -115,7 +120,7 @@ namespace NoAsyncBefore { * ``` */ namespace NoAsyncTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -132,7 +137,7 @@ namespace NoAsyncTests { * ``` */ namespace AssertionBeforeScreenshot { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -149,7 +154,7 @@ namespace AssertionBeforeScreenshot { * ``` */ namespace RequireDataSelectors { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -166,7 +171,7 @@ namespace RequireDataSelectors { * ``` */ namespace NoForce { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -183,7 +188,7 @@ namespace NoForce { * ``` */ namespace NoPause { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -200,7 +205,7 @@ namespace NoPause { * ``` */ namespace NoDebug { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } export type EslintCypressRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts b/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts index 653d3b75ae..7ee2d514df 100644 --- a/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce functional parameters. @@ -678,8 +682,9 @@ namespace FunctionalParameters { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1320,8 +1325,9 @@ namespace ImmutableData { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1377,8 +1383,9 @@ namespace NoClasses { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1434,8 +1441,9 @@ namespace NoClassInheritance { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1485,8 +1493,9 @@ namespace NoConditionalStatements { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1540,8 +1549,9 @@ namespace NoExpressionStatements { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1595,8 +1605,9 @@ namespace NoLet { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1614,7 +1625,7 @@ namespace NoLet { * ``` */ namespace NoLoopStatements { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1658,8 +1669,9 @@ namespace NoMixedTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1677,7 +1689,7 @@ namespace NoMixedTypes { * ``` */ namespace NoPromiseReject { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1725,8 +1737,9 @@ namespace NoReturnVoid { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1744,7 +1757,7 @@ namespace NoReturnVoid { * ``` */ namespace NoThisExpressions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1784,8 +1797,9 @@ namespace NoThrowStatements { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1829,8 +1843,9 @@ namespace NoTryStatements { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3613,8 +3628,9 @@ namespace PreferImmutableTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3655,8 +3671,9 @@ namespace PreferPropertySignatures { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3768,8 +3785,9 @@ namespace PreferTacit { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3806,8 +3824,9 @@ namespace ReadonlyType { export type Options = 'generic' | 'keyword'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4023,8 +4042,9 @@ namespace TypeDeclarationImmutability { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintFunctionalRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-import-rules.mts b/packages/eslint-configs/src/types/rules/eslint-import-rules.mts index 09741b56c3..8103e5e0e3 100644 --- a/packages/eslint-configs/src/types/rules/eslint-import-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-import-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Ensure imports point to a file/module that can be resolved. @@ -67,8 +71,9 @@ namespace NoUnresolved { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -106,8 +111,9 @@ namespace Named { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -123,7 +129,7 @@ namespace Named { * ``` */ namespace Default { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -168,8 +174,9 @@ namespace Namespace { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -212,8 +219,9 @@ namespace NoNamespace { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -229,7 +237,7 @@ namespace NoNamespace { * ``` */ namespace Export { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -245,7 +253,7 @@ namespace Export { * ``` */ namespace NoMutableExports { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -397,8 +405,9 @@ namespace Extensions { | readonly [Record]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -501,8 +510,9 @@ namespace NoRestrictedPaths { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -563,8 +573,9 @@ namespace NoInternalModules { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -580,7 +591,7 @@ namespace NoInternalModules { * ``` */ namespace GroupExports { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -637,8 +648,9 @@ namespace NoRelativePackages { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -694,8 +706,9 @@ namespace NoRelativeParentImports { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -731,8 +744,9 @@ namespace ConsistentTypeSpecifierStyle { export type Options = 'prefer-inline' | 'prefer-top-level'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -749,7 +763,7 @@ namespace ConsistentTypeSpecifierStyle { * ``` */ namespace NoSelfImport { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -850,8 +864,9 @@ namespace NoCycle { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -867,7 +882,7 @@ namespace NoCycle { * ``` */ namespace NoNamedDefault { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -883,7 +898,7 @@ namespace NoNamedDefault { * ``` */ namespace NoNamedAsDefault { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -899,7 +914,7 @@ namespace NoNamedAsDefault { * ``` */ namespace NoNamedAsDefaultMember { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -981,8 +996,9 @@ namespace NoAnonymousDefaultExport { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1098,8 +1114,9 @@ namespace NoUnusedModules { ); export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1167,8 +1184,9 @@ namespace NoCommonjs { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1184,7 +1202,7 @@ namespace NoCommonjs { * ``` */ namespace NoAmd { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1227,8 +1245,9 @@ namespace NoDuplicates { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1263,8 +1282,9 @@ namespace First { export type Options = 'absolute-first' | 'disable-absolute-first'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1306,8 +1326,9 @@ namespace MaxDependencies { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1388,8 +1409,9 @@ namespace NoExtraneousDependencies { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1446,8 +1468,9 @@ namespace NoAbsolutePath { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1489,8 +1512,9 @@ namespace NoNodejsModules { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1506,7 +1530,7 @@ namespace NoNodejsModules { * ``` */ namespace NoWebpackLoaderSyntax { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1705,8 +1729,9 @@ namespace Order { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1754,8 +1779,9 @@ namespace NewlineAfterImport { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1798,8 +1824,9 @@ namespace PreferDefaultExport { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1815,7 +1842,7 @@ namespace PreferDefaultExport { * ``` */ namespace NoDefaultExport { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1831,7 +1858,7 @@ namespace NoDefaultExport { * ``` */ namespace NoNamedExport { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1869,8 +1896,9 @@ namespace NoDynamicRequire { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1886,7 +1914,7 @@ namespace NoDynamicRequire { * ``` */ namespace Unambiguous { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1948,8 +1976,9 @@ namespace NoUnassignedImport { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1992,8 +2021,9 @@ namespace NoUselessPathSegments { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2044,8 +2074,9 @@ namespace DynamicImportChunkname { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2083,8 +2114,9 @@ namespace NoImportModuleExports { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2102,7 +2134,7 @@ namespace NoImportModuleExports { * ``` */ namespace NoEmptyNamedBlocks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2118,7 +2150,7 @@ namespace NoEmptyNamedBlocks { * ``` */ namespace ExportsLast { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2134,7 +2166,7 @@ namespace ExportsLast { * ``` */ namespace NoDeprecated { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** diff --git a/packages/eslint-configs/src/types/rules/eslint-jest-rules.mts b/packages/eslint-configs/src/types/rules/eslint-jest-rules.mts index f031272189..4deb7c2bf6 100644 --- a/packages/eslint-configs/src/types/rules/eslint-jest-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-jest-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce `test` and `it` usage conventions @@ -51,8 +55,9 @@ namespace ConsistentTestIt { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -99,8 +104,9 @@ namespace ExpectExpect { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -138,8 +144,9 @@ namespace MaxExpects { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -177,8 +184,9 @@ namespace MaxNestedDescribe { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -194,7 +202,7 @@ namespace MaxNestedDescribe { * ``` */ namespace NoAliasMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -209,7 +217,7 @@ namespace NoAliasMethods { * ``` */ namespace NoCommentedOutTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -224,7 +232,7 @@ namespace NoCommentedOutTests { * ``` */ namespace NoConditionalExpect { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -239,7 +247,7 @@ namespace NoConditionalExpect { * ``` */ namespace NoConditionalInTest { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -254,7 +262,7 @@ namespace NoConditionalInTest { * ``` */ namespace NoConfusingSetTimeout { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -270,7 +278,7 @@ namespace NoConfusingSetTimeout { * ``` */ namespace NoDeprecatedFunctions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -285,7 +293,7 @@ namespace NoDeprecatedFunctions { * ``` */ namespace NoDisabledTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -301,7 +309,7 @@ namespace NoDisabledTests { * ``` */ namespace NoDoneCallback { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -316,7 +324,7 @@ namespace NoDoneCallback { * ``` */ namespace NoDuplicateHooks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -331,7 +339,7 @@ namespace NoDuplicateHooks { * ``` */ namespace NoExport { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -347,7 +355,7 @@ namespace NoExport { * ``` */ namespace NoFocusedTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -390,8 +398,9 @@ namespace NoHooks { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -406,7 +415,7 @@ namespace NoHooks { * ``` */ namespace NoIdenticalTitle { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -421,7 +430,7 @@ namespace NoIdenticalTitle { * ``` */ namespace NoInterpolationInSnapshots { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -437,7 +446,7 @@ namespace NoInterpolationInSnapshots { * ``` */ namespace NoJasmineGlobals { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -485,8 +494,9 @@ namespace NoLargeSnapshots { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -501,7 +511,7 @@ namespace NoLargeSnapshots { * ``` */ namespace NoMocksImport { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -536,8 +546,9 @@ namespace NoRestrictedJestMethods { export type Options = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -572,8 +583,9 @@ namespace NoRestrictedMatchers { export type Options = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -613,8 +625,9 @@ namespace NoStandaloneExpect { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -630,7 +643,7 @@ namespace NoStandaloneExpect { * ``` */ namespace NoTestPrefixes { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -645,7 +658,7 @@ namespace NoTestPrefixes { * ``` */ namespace NoTestReturnStatement { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -661,7 +674,7 @@ namespace NoTestReturnStatement { * ``` */ namespace NoUntypedMockFactory { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -678,7 +691,7 @@ namespace NoUntypedMockFactory { * ``` */ namespace PaddingAroundAfterAllBlocks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -695,7 +708,7 @@ namespace PaddingAroundAfterAllBlocks { * ``` */ namespace PaddingAroundAfterEachBlocks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -712,7 +725,7 @@ namespace PaddingAroundAfterEachBlocks { * ``` */ namespace PaddingAroundAll { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -729,7 +742,7 @@ namespace PaddingAroundAll { * ``` */ namespace PaddingAroundBeforeAllBlocks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -746,7 +759,7 @@ namespace PaddingAroundBeforeAllBlocks { * ``` */ namespace PaddingAroundBeforeEachBlocks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -763,7 +776,7 @@ namespace PaddingAroundBeforeEachBlocks { * ``` */ namespace PaddingAroundDescribeBlocks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -780,7 +793,7 @@ namespace PaddingAroundDescribeBlocks { * ``` */ namespace PaddingAroundExpectGroups { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -797,7 +810,7 @@ namespace PaddingAroundExpectGroups { * ``` */ namespace PaddingAroundTestBlocks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -812,7 +825,7 @@ namespace PaddingAroundTestBlocks { * ``` */ namespace PreferCalledWith { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -828,7 +841,7 @@ namespace PreferCalledWith { * ``` */ namespace PreferComparisonMatcher { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -843,7 +856,7 @@ namespace PreferComparisonMatcher { * ``` */ namespace PreferEach { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -859,7 +872,7 @@ namespace PreferEach { * ``` */ namespace PreferEqualityMatcher { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -905,8 +918,9 @@ namespace PreferExpectAssertions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -922,7 +936,7 @@ namespace PreferExpectAssertions { * ``` */ namespace PreferExpectResolves { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -937,7 +951,7 @@ namespace PreferExpectResolves { * ``` */ namespace PreferHooksInOrder { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -952,7 +966,7 @@ namespace PreferHooksInOrder { * ``` */ namespace PreferHooksOnTop { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1008,8 +1022,9 @@ namespace PreferImportingJestGlobals { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1025,7 +1040,7 @@ namespace PreferImportingJestGlobals { * ``` */ namespace PreferJestMocked { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1085,8 +1100,9 @@ namespace PreferLowercaseTitle { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1102,7 +1118,7 @@ namespace PreferLowercaseTitle { * ``` */ namespace PreferMockPromiseShorthand { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1135,8 +1151,9 @@ namespace PreferSnapshotHint { export type Options = 'always' | 'multi'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1152,7 +1169,7 @@ namespace PreferSnapshotHint { * ``` */ namespace PreferSpyOn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1168,7 +1185,7 @@ namespace PreferSpyOn { * ``` */ namespace PreferStrictEqual { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1184,7 +1201,7 @@ namespace PreferStrictEqual { * ``` */ namespace PreferToBe { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1200,7 +1217,7 @@ namespace PreferToBe { * ``` */ namespace PreferToContain { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1216,7 +1233,7 @@ namespace PreferToContain { * ``` */ namespace PreferToHaveLength { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1232,7 +1249,7 @@ namespace PreferToHaveLength { * ``` */ namespace PreferTodo { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1272,8 +1289,9 @@ namespace RequireHook { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1288,7 +1306,7 @@ namespace RequireHook { * ``` */ namespace RequireToThrowMessage { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1326,8 +1344,9 @@ namespace RequireTopLevelDescribe { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1367,8 +1386,9 @@ namespace UnboundMethod { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1383,7 +1403,7 @@ namespace UnboundMethod { * ``` */ namespace ValidDescribeCallback { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1398,7 +1418,7 @@ namespace ValidDescribeCallback { * ``` */ namespace ValidExpectInPromise { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1454,8 +1474,9 @@ namespace ValidExpect { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1560,8 +1581,9 @@ namespace ValidTitle { >; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintJestRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-jsx-a11y-rules.mts b/packages/eslint-configs/src/types/rules/eslint-jsx-a11y-rules.mts index 46e5af4e0b..f79392510e 100644 --- a/packages/eslint-configs/src/types/rules/eslint-jsx-a11y-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-jsx-a11y-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce emojis are wrapped in `` and provide screen reader access. @@ -106,8 +110,9 @@ namespace AltText { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -149,8 +154,9 @@ namespace AnchorAmbiguousText { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -191,8 +197,9 @@ namespace AnchorHasContent { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -261,8 +268,9 @@ namespace AnchorIsValid { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -291,8 +299,9 @@ namespace AriaActivedescendantHasTabindex { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -321,8 +330,9 @@ namespace AriaProps { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -351,8 +361,9 @@ namespace AriaProptypes { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -398,8 +409,9 @@ namespace AriaRole { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -429,8 +441,9 @@ namespace AriaUnsupportedElements { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -471,8 +484,9 @@ namespace AutocompleteValid { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -502,8 +516,9 @@ namespace ClickEventsHaveKeyEvents { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -578,8 +593,9 @@ namespace ControlHasAssociatedLabel { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -620,8 +636,9 @@ namespace HeadingHasContent { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -650,8 +667,9 @@ namespace HtmlHasLang { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -680,8 +698,9 @@ namespace IframeHasTitle { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -732,8 +751,9 @@ namespace ImgRedundantAlt { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -848,8 +868,9 @@ namespace InteractiveSupportsFocus { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -927,8 +948,9 @@ namespace LabelHasAssociatedControl { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1049,8 +1071,9 @@ namespace Lang { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1110,8 +1133,9 @@ namespace MediaHasCaption { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1166,8 +1190,9 @@ namespace MouseEventsHaveKeyEvents { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1197,8 +1222,9 @@ namespace NoAccessKey { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1227,8 +1253,9 @@ namespace NoAriaHiddenOnFocusable { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1265,8 +1292,9 @@ namespace NoAutofocus { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1313,8 +1341,9 @@ namespace NoDistractingElements { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1349,8 +1378,9 @@ namespace NoInteractiveElementToNoninteractiveRole { export type Options = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1392,8 +1422,9 @@ namespace NoNoninteractiveElementInteractions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1428,8 +1459,9 @@ namespace NoNoninteractiveElementToInteractiveRole { export type Options = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1483,8 +1515,9 @@ namespace NoNoninteractiveTabindex { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1547,8 +1580,9 @@ namespace NoRedundantRoles { export type Options = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1590,8 +1624,9 @@ namespace NoStaticElementInteractions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1620,8 +1655,9 @@ namespace PreferTagOverRole { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1651,8 +1687,9 @@ namespace RoleHasRequiredAriaProps { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1682,8 +1719,9 @@ namespace RoleSupportsAriaProps { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1712,8 +1750,9 @@ namespace Scope { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1742,8 +1781,9 @@ namespace TabindexNoPositive { export type Options = UnknownRecord; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintJsxA11yRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts b/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts index afa1ba1532..2fecd39001 100644 --- a/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce assertion to be made in a test body @@ -45,8 +49,9 @@ namespace ExpectExpect { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -86,8 +91,9 @@ namespace MaxExpects { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -127,8 +133,9 @@ namespace MaxNestedDescribe { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -171,8 +178,9 @@ namespace MissingPlaywrightAwait { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -189,7 +197,7 @@ namespace MissingPlaywrightAwait { * ``` */ namespace NoCommentedOutTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -206,7 +214,7 @@ namespace NoCommentedOutTests { * ``` */ namespace NoConditionalExpect { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -223,7 +231,7 @@ namespace NoConditionalExpect { * ``` */ namespace NoConditionalInTest { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -240,7 +248,7 @@ namespace NoConditionalInTest { * ``` */ namespace NoDuplicateHooks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -258,7 +266,7 @@ namespace NoDuplicateHooks { * ``` */ namespace NoElementHandle { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -276,7 +284,7 @@ namespace NoElementHandle { * ``` */ namespace NoEval { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -294,7 +302,7 @@ namespace NoEval { * ``` */ namespace NoFocusedTest { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -311,7 +319,7 @@ namespace NoFocusedTest { * ``` */ namespace NoForceOption { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -328,7 +336,7 @@ namespace NoForceOption { * ``` */ namespace NoGetByTitle { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -373,8 +381,9 @@ namespace NoHooks { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -391,7 +400,7 @@ namespace NoHooks { * ``` */ namespace NoNestedStep { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -408,7 +417,7 @@ namespace NoNestedStep { * ``` */ namespace NoNetworkidle { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -425,7 +434,7 @@ namespace NoNetworkidle { * ``` */ namespace NoNthMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -442,7 +451,7 @@ namespace NoNthMethods { * ``` */ namespace NoPagePause { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -484,8 +493,9 @@ namespace NoRawLocators { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -522,8 +532,9 @@ namespace NoRestrictedMatchers { export type Options = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -564,8 +575,9 @@ namespace NoSkippedTest { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -606,8 +618,9 @@ namespace NoSlowedTest { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -625,7 +638,7 @@ namespace NoSlowedTest { * ``` */ namespace NoStandaloneExpect { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -643,7 +656,7 @@ namespace NoStandaloneExpect { * ``` */ namespace NoUnsafeReferences { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -661,7 +674,7 @@ namespace NoUnsafeReferences { * ``` */ namespace NoUselessAwait { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -679,7 +692,7 @@ namespace NoUselessAwait { * ``` */ namespace NoUselessNot { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -697,7 +710,7 @@ namespace NoUselessNot { * ``` */ namespace NoWaitForSelector { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -715,7 +728,7 @@ namespace NoWaitForSelector { * ``` */ namespace NoWaitForTimeout { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -733,7 +746,7 @@ namespace NoWaitForTimeout { * ``` */ namespace PreferComparisonMatcher { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -751,7 +764,7 @@ namespace PreferComparisonMatcher { * ``` */ namespace PreferEqualityMatcher { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -768,7 +781,7 @@ namespace PreferEqualityMatcher { * ``` */ namespace PreferHooksInOrder { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -785,7 +798,7 @@ namespace PreferHooksInOrder { * ``` */ namespace PreferHooksOnTop { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -802,7 +815,7 @@ namespace PreferHooksOnTop { * ``` */ namespace PreferLocator { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -862,8 +875,9 @@ namespace PreferLowercaseTitle { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -904,8 +918,9 @@ namespace PreferNativeLocators { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -924,7 +939,7 @@ namespace PreferNativeLocators { * ``` */ namespace PreferStrictEqual { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -942,7 +957,7 @@ namespace PreferStrictEqual { * ``` */ namespace PreferToBe { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -960,7 +975,7 @@ namespace PreferToBe { * ``` */ namespace PreferToContain { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -978,7 +993,7 @@ namespace PreferToContain { * ``` */ namespace PreferToHaveCount { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -996,7 +1011,7 @@ namespace PreferToHaveCount { * ``` */ namespace PreferToHaveLength { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1014,7 +1029,7 @@ namespace PreferToHaveLength { * ``` */ namespace PreferWebFirstAssertions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1056,8 +1071,9 @@ namespace RequireHook { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1074,7 +1090,7 @@ namespace RequireHook { * ``` */ namespace RequireSoftAssertions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1091,7 +1107,7 @@ namespace RequireSoftAssertions { * ``` */ namespace RequireToThrowMessage { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1131,8 +1147,9 @@ namespace RequireTopLevelDescribe { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1149,7 +1166,7 @@ namespace RequireTopLevelDescribe { * ``` */ namespace ValidDescribeCallback { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1194,8 +1211,9 @@ namespace ValidExpect { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1212,7 +1230,7 @@ namespace ValidExpect { * ``` */ namespace ValidExpectInPromise { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1326,8 +1344,9 @@ namespace ValidTitle { >; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintPlaywrightRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts b/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts index 9914fd3554..203d762791 100644 --- a/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce consistent use of `output` assertions in rule tests @@ -42,8 +46,9 @@ namespace ConsistentOutput { export type Options = 'always' | 'consistent'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -60,7 +65,7 @@ namespace ConsistentOutput { * ``` */ namespace FixerReturn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -97,8 +102,9 @@ namespace MetaPropertyOrdering { export type Options = readonly unknown[]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -116,7 +122,7 @@ namespace MetaPropertyOrdering { * ``` */ namespace NoDeprecatedContextMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -134,7 +140,7 @@ namespace NoDeprecatedContextMethods { * ``` */ namespace NoDeprecatedReportApi { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -152,7 +158,7 @@ namespace NoDeprecatedReportApi { * ``` */ namespace NoIdenticalTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -169,7 +175,7 @@ namespace NoIdenticalTests { * ``` */ namespace NoMetaSchemaDefault { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -186,7 +192,7 @@ namespace NoMetaSchemaDefault { * ``` */ namespace NoMissingMessageIds { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -203,7 +209,7 @@ namespace NoMissingMessageIds { * ``` */ namespace NoMissingPlaceholders { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -221,7 +227,7 @@ namespace NoMissingPlaceholders { * ``` */ namespace NoOnlyTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -269,8 +275,9 @@ namespace NoPropertyInNode { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -287,7 +294,7 @@ namespace NoPropertyInNode { * ``` */ namespace NoUnusedMessageIds { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -304,7 +311,7 @@ namespace NoUnusedMessageIds { * ``` */ namespace NoUnusedPlaceholders { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -323,7 +330,7 @@ namespace NoUnusedPlaceholders { * ``` */ namespace NoUselessTokenRange { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -341,7 +348,7 @@ namespace NoUselessTokenRange { * ``` */ namespace PreferMessageIds { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -359,7 +366,7 @@ namespace PreferMessageIds { * ``` */ namespace PreferObjectRule { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -377,7 +384,7 @@ namespace PreferObjectRule { * ``` */ namespace PreferOutputNull { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -394,7 +401,7 @@ namespace PreferOutputNull { * ``` */ namespace PreferPlaceholders { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -411,7 +418,7 @@ namespace PreferPlaceholders { * ``` */ namespace PreferReplaceText { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -444,8 +451,9 @@ namespace ReportMessageFormat { export type Options = string; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -463,7 +471,7 @@ namespace ReportMessageFormat { * ``` */ namespace RequireMetaDefaultOptions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -509,8 +517,9 @@ namespace RequireMetaDocsDescription { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -553,8 +562,9 @@ namespace RequireMetaDocsRecommended { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -600,8 +610,9 @@ namespace RequireMetaDocsUrl { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -648,8 +659,9 @@ namespace RequireMetaFixable { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -667,7 +679,7 @@ namespace RequireMetaFixable { * ``` */ namespace RequireMetaHasSuggestions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -684,7 +696,7 @@ namespace RequireMetaHasSuggestions { * ``` */ namespace RequireMetaSchemaDescription { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -730,8 +742,9 @@ namespace RequireMetaSchema { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -748,7 +761,7 @@ namespace RequireMetaSchema { * ``` */ namespace RequireMetaType { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -785,8 +798,9 @@ namespace TestCasePropertyOrdering { export type Options = readonly unknown[]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -832,8 +846,9 @@ namespace TestCaseShorthandStrings { | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintPluginRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-prefer-arrow-functions-rules.mts b/packages/eslint-configs/src/types/rules/eslint-prefer-arrow-functions-rules.mts index 1ffb8717e5..c0404c3b85 100644 --- a/packages/eslint-configs/src/types/rules/eslint-prefer-arrow-functions-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-prefer-arrow-functions-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Auto-fix plain Functions into Arrow Functions, in all cases where conversion @@ -75,8 +79,9 @@ namespace PreferArrowFunctions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintPreferArrowFunctionRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-promise-rules.mts b/packages/eslint-configs/src/types/rules/eslint-promise-rules.mts index ee95ca759d..09f50d11bc 100644 --- a/packages/eslint-configs/src/types/rules/eslint-promise-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-promise-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce consistent param names and ordering when creating new promises. @@ -42,8 +46,9 @@ namespace ParamNames { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -81,8 +86,9 @@ namespace NoReturnWrap { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -129,8 +135,9 @@ namespace AlwaysReturn { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -189,8 +196,9 @@ namespace CatchOrReturn { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -205,7 +213,7 @@ namespace CatchOrReturn { * ``` */ namespace PreferAwaitToCallbacks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -242,8 +250,9 @@ namespace PreferAwaitToThen { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -259,7 +268,7 @@ namespace PreferAwaitToThen { * ``` */ namespace PreferCatch { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -275,7 +284,7 @@ namespace PreferCatch { * ``` */ namespace NoNative { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -320,8 +329,9 @@ namespace NoCallbackInPromise { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -336,7 +346,7 @@ namespace NoCallbackInPromise { * ``` */ namespace NoPromiseInCallback { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -351,7 +361,7 @@ namespace NoPromiseInCallback { * ``` */ namespace NoNesting { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -367,7 +377,7 @@ namespace NoNesting { * ``` */ namespace AvoidNew { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -383,7 +393,7 @@ namespace AvoidNew { * ``` */ namespace NoNewStatics { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -398,7 +408,7 @@ namespace NoNewStatics { * ``` */ namespace NoReturnInFinally { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -438,8 +448,9 @@ namespace ValidParams { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -454,7 +465,7 @@ namespace ValidParams { * ``` */ namespace NoMultipleResolved { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -494,8 +505,9 @@ namespace SpecOnly { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintPromiseRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-react-hooks-rules.mts b/packages/eslint-configs/src/types/rules/eslint-react-hooks-rules.mts index 9f7f3d161d..1517f4fe9e 100644 --- a/packages/eslint-configs/src/types/rules/eslint-react-hooks-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-react-hooks-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforces the Rules of Hooks @@ -17,7 +21,7 @@ type SpreadOptionsIfIsArray = * ``` */ namespace RulesOfHooks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -62,8 +66,9 @@ namespace ExhaustiveDeps { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintReactHooksRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-react-refresh-rules.mts b/packages/eslint-configs/src/types/rules/eslint-react-refresh-rules.mts index 71bec58d25..b282c96ea5 100644 --- a/packages/eslint-configs/src/types/rules/eslint-react-refresh-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-react-refresh-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; namespace OnlyExportComponents { /** @@ -45,8 +49,9 @@ namespace OnlyExportComponents { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintReactRefreshRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-react-rules.mts b/packages/eslint-configs/src/types/rules/eslint-react-rules.mts index 17010e58d9..60263becf5 100644 --- a/packages/eslint-configs/src/types/rules/eslint-react-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-react-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforces consistent naming for boolean props @@ -61,8 +65,9 @@ namespace BooleanPropNaming { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -111,8 +116,9 @@ namespace ButtonHasType { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -153,8 +159,9 @@ namespace CheckedRequiresOnchangeOrReadonly { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -192,8 +199,9 @@ namespace DefaultPropsMatchPropTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -250,9 +258,10 @@ namespace DestructuringAssignment { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -294,8 +303,9 @@ namespace DisplayName { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -487,8 +497,9 @@ namespace ForbidComponentProps { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -561,8 +572,9 @@ namespace ForbidDomProps { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -628,8 +640,9 @@ namespace ForbidElements { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -667,8 +680,9 @@ namespace ForbidForeignPropTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -718,8 +732,9 @@ namespace ForbidPropTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -737,7 +752,7 @@ namespace ForbidPropTypes { * ``` */ namespace ForwardRefUsesRef { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -827,8 +842,9 @@ namespace FunctionComponentDefinition { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -870,8 +886,9 @@ namespace HookUseState { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -887,7 +904,7 @@ namespace HookUseState { * ``` */ namespace IframeMissingSandbox { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -996,8 +1013,9 @@ namespace JsxBooleanValue { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1014,7 +1032,7 @@ namespace JsxBooleanValue { * ``` */ namespace JsxChildElementSpacing { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1117,8 +1135,9 @@ namespace JsxClosingBracketLocation { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1173,8 +1192,9 @@ namespace JsxClosingTagLocation { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1316,8 +1336,9 @@ namespace JsxCurlySpacing { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1383,8 +1404,9 @@ namespace JsxCurlyNewline { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1418,8 +1440,9 @@ namespace JsxEqualsSpacing { export type Options = 'always' | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1471,8 +1494,9 @@ namespace JsxFilenameExtension { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1514,8 +1538,9 @@ namespace JsxFirstPropNewLine { | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1688,8 +1713,9 @@ namespace JsxHandlerNames { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1746,9 +1772,10 @@ namespace JsxIndent { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -1818,8 +1845,9 @@ namespace JsxIndentProps { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1868,8 +1896,9 @@ namespace JsxKey { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1908,8 +1937,9 @@ namespace JsxMaxDepth { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1988,8 +2018,9 @@ namespace JsxMaxPropsPerLine { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2051,8 +2082,9 @@ namespace JsxNewline { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2111,8 +2143,9 @@ namespace JsxNoBind { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2128,7 +2161,7 @@ namespace JsxNoBind { * ``` */ namespace JsxNoCommentTextnodes { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2145,7 +2178,7 @@ namespace JsxNoCommentTextnodes { * ``` */ namespace JsxNoConstructedContextValues { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2183,8 +2216,9 @@ namespace JsxNoDuplicateProps { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2234,8 +2268,9 @@ namespace JsxNoLeakedRender { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2329,8 +2364,9 @@ namespace JsxNoLiterals { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2433,8 +2469,9 @@ namespace JsxNoScriptUrl { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2494,8 +2531,9 @@ namespace JsxNoTargetBlank { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2535,8 +2573,9 @@ namespace JsxNoUselessFragment { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2583,8 +2622,9 @@ namespace JsxOneExpressionPerLine { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2622,8 +2662,9 @@ namespace JsxNoUndef { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2696,8 +2737,9 @@ namespace JsxCurlyBracePresence { | ('always' | 'ignore' | 'never'); export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2755,8 +2797,9 @@ namespace JsxPascalCase { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2790,8 +2833,9 @@ namespace JsxFragments { export type Options = 'element' | 'syntax'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2808,7 +2852,7 @@ namespace JsxFragments { * ``` */ namespace JsxPropsNoMultiSpaces { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2901,8 +2945,9 @@ namespace JsxPropsNoSpreading { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2918,7 +2963,7 @@ namespace JsxPropsNoSpreading { * ``` */ namespace JsxPropsNoSpreadMulti { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3028,8 +3073,9 @@ namespace JsxSortProps { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3145,8 +3191,9 @@ namespace JsxTagSpacing { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3162,7 +3209,7 @@ namespace JsxTagSpacing { * ``` */ namespace JsxUsesReact { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3178,7 +3225,7 @@ namespace JsxUsesReact { * ``` */ namespace JsxUsesVars { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3332,8 +3379,9 @@ namespace JsxWrapMultilines { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3370,8 +3418,9 @@ namespace NoInvalidHtmlAttribute { export type Options = readonly 'rel'[]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3387,7 +3436,7 @@ namespace NoInvalidHtmlAttribute { * ``` */ namespace NoAccessStateInSetstate { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3403,7 +3452,7 @@ namespace NoAccessStateInSetstate { * ``` */ namespace NoAdjacentInlineElements { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3419,7 +3468,7 @@ namespace NoAdjacentInlineElements { * ``` */ namespace NoArrayIndexKey { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3436,7 +3485,7 @@ namespace NoArrayIndexKey { * ``` */ namespace NoArrowFunctionLifecycle { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3475,8 +3524,9 @@ namespace NoChildrenProp { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3520,8 +3570,9 @@ namespace NoDanger { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3538,7 +3589,7 @@ namespace NoDanger { * ``` */ namespace NoDangerWithChildren { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3554,7 +3605,7 @@ namespace NoDangerWithChildren { * ``` */ namespace NoDeprecated { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3586,8 +3637,9 @@ namespace NoDidMountSetState { export type Options = 'disallow-in-func'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3619,8 +3671,9 @@ namespace NoDidUpdateSetState { export type Options = 'disallow-in-func'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3636,7 +3689,7 @@ namespace NoDidUpdateSetState { * ``` */ namespace NoDirectMutationState { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3652,7 +3705,7 @@ namespace NoDirectMutationState { * ``` */ namespace NoFindDomNode { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3668,7 +3721,7 @@ namespace NoFindDomNode { * ``` */ namespace NoIsMounted { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3707,8 +3760,9 @@ namespace NoMultiComp { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3724,7 +3778,7 @@ namespace NoMultiComp { * ``` */ namespace NoNamespace { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3740,7 +3794,7 @@ namespace NoNamespace { * ``` */ namespace NoSetState { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3778,8 +3832,9 @@ namespace NoStringRefs { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3795,7 +3850,7 @@ namespace NoStringRefs { * ``` */ namespace NoRedundantShouldComponentUpdate { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3811,7 +3866,7 @@ namespace NoRedundantShouldComponentUpdate { * ``` */ namespace NoRenderReturnValue { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3827,7 +3882,7 @@ namespace NoRenderReturnValue { * ``` */ namespace NoThisInSfc { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3843,7 +3898,7 @@ namespace NoThisInSfc { * ``` */ namespace NoTypos { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3911,8 +3966,9 @@ namespace NoUnescapedEntities { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3959,8 +4015,9 @@ namespace NoUnknownProperty { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3999,8 +4056,9 @@ namespace NoUnsafe { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4049,8 +4107,9 @@ namespace NoUnstableNestedComponents { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4066,7 +4125,7 @@ namespace NoUnstableNestedComponents { * ``` */ namespace NoUnusedClassComponentMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4119,8 +4178,9 @@ namespace NoUnusedPropTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4136,7 +4196,7 @@ namespace NoUnusedPropTypes { * ``` */ namespace NoUnusedState { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4153,7 +4213,7 @@ namespace NoUnusedState { * ``` */ namespace NoObjectTypeAsDefaultProp { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4185,8 +4245,9 @@ namespace NoWillUpdateSetState { export type Options = 'disallow-in-func'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4219,8 +4280,9 @@ namespace PreferEs6Class { export type Options = 'always' | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4236,7 +4298,7 @@ namespace PreferEs6Class { * ``` */ namespace PreferExactProps { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4253,7 +4315,7 @@ namespace PreferExactProps { * ``` */ namespace PreferReadOnlyProps { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4292,8 +4354,9 @@ namespace PreferStatelessFunction { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4345,8 +4408,9 @@ namespace PropTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4362,7 +4426,7 @@ namespace PropTypes { * ``` */ namespace ReactInJsxScope { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4418,8 +4482,9 @@ namespace RequireDefaultProps { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4460,8 +4525,9 @@ namespace RequireOptimization { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4477,7 +4543,7 @@ namespace RequireOptimization { * ``` */ namespace RequireRenderReturn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4522,8 +4588,9 @@ namespace SelfClosingComp { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4576,8 +4643,9 @@ namespace SortComp { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4615,8 +4683,9 @@ namespace SortDefaultProps { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4675,8 +4744,9 @@ namespace SortPropTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4709,8 +4779,9 @@ namespace StateInConstructor { export type Options = 'always' | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4822,9 +4893,10 @@ namespace StaticPropertyPlacement { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -4867,8 +4939,9 @@ namespace StylePropObject { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4884,7 +4957,7 @@ namespace StylePropObject { * ``` */ namespace VoidDomElementsNoChildren { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } export type EslintReactRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-rules.mts b/packages/eslint-configs/src/types/rules/eslint-rules.mts index 2849900fce..c3c638b014 100644 --- a/packages/eslint-configs/src/types/rules/eslint-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce getter and setter pairs in objects and classes @@ -47,8 +51,9 @@ namespace AccessorPairs { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -195,8 +200,9 @@ namespace ArrayCallbackReturn { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -335,8 +341,9 @@ namespace ArrowBodyStyle { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -434,7 +441,7 @@ namespace ArrowSpacing { * ``` */ namespace BlockScopedVar { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -604,8 +611,9 @@ namespace Camelcase { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -713,9 +721,10 @@ namespace CapitalizedComments { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -760,8 +769,9 @@ namespace ClassMethodsUseThis { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -978,8 +988,9 @@ namespace Complexity { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1059,8 +1070,9 @@ namespace ConsistentReturn { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1093,8 +1105,9 @@ namespace ConsistentThis { export type Options = readonly string[]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1110,7 +1123,7 @@ namespace ConsistentThis { * ``` */ namespace ConstructorSuper { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1167,8 +1180,9 @@ namespace Curly { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1206,8 +1220,9 @@ namespace DefaultCase { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1223,7 +1238,7 @@ namespace DefaultCase { * ``` */ namespace DefaultCaseLast { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1239,7 +1254,7 @@ namespace DefaultCaseLast { * ``` */ namespace DefaultParamLast { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1314,8 +1329,9 @@ namespace DotNotation { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1415,8 +1431,9 @@ namespace Eqeqeq { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1432,7 +1449,7 @@ namespace Eqeqeq { * ``` */ namespace ForDirection { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1574,8 +1591,9 @@ namespace FuncNameMatching { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1630,8 +1648,9 @@ namespace FuncNames { export type Value = 'always' | 'as-needed' | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1694,9 +1713,10 @@ namespace FuncStyle { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -1938,8 +1958,9 @@ namespace GetterReturn { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1990,8 +2011,9 @@ namespace GroupedAccessorPairs { export type Options = 'anyOrder' | 'getBeforeSet' | 'setBeforeGet'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2007,7 +2029,7 @@ namespace GroupedAccessorPairs { * ``` */ namespace GuardForIn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2097,8 +2119,9 @@ namespace IdDenylist { export type Options = readonly string[]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2163,8 +2186,9 @@ namespace IdLength { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2219,9 +2243,10 @@ namespace IdMatch { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -2773,8 +2798,9 @@ namespace InitDeclarations { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4280,8 +4306,9 @@ namespace LogicalAssignmentOperators { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4334,8 +4361,9 @@ namespace MaxClassesPerFile { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4389,8 +4417,9 @@ namespace MaxDepth { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4605,8 +4634,9 @@ namespace MaxLines { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4667,8 +4697,9 @@ namespace MaxLinesPerFunction { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4722,8 +4753,9 @@ namespace MaxNestedCallbacks { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4777,8 +4809,9 @@ namespace MaxParams { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4845,9 +4878,10 @@ namespace MaxStatements { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -5039,8 +5073,9 @@ namespace NewCap { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5176,7 +5211,7 @@ namespace NewlinePerChainedCall { * ``` */ namespace NoAlert { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5193,7 +5228,7 @@ namespace NoAlert { * ``` */ namespace NoArrayConstructor { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5209,7 +5244,7 @@ namespace NoArrayConstructor { * ``` */ namespace NoAsyncPromiseExecutor { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5225,7 +5260,7 @@ namespace NoAsyncPromiseExecutor { * ``` */ namespace NoAwaitInLoop { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5299,8 +5334,9 @@ namespace NoBitwise { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5333,7 +5369,7 @@ namespace NoBufferConstructor { * ``` */ namespace NoCaller { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5350,7 +5386,7 @@ namespace NoCaller { * ``` */ namespace NoCaseDeclarations { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5384,7 +5420,7 @@ namespace NoCatchShadow { * ``` */ namespace NoClassAssign { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5400,7 +5436,7 @@ namespace NoClassAssign { * ``` */ namespace NoCompareNegZero { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5433,8 +5469,9 @@ namespace NoCondAssign { export type Options = 'always' | 'except-parens'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5519,8 +5556,9 @@ namespace NoConsole { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5536,7 +5574,7 @@ namespace NoConsole { * ``` */ namespace NoConstAssign { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5552,7 +5590,7 @@ namespace NoConstAssign { * ``` */ namespace NoConstantBinaryExpression { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5596,8 +5634,9 @@ namespace NoConstantCondition { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5613,7 +5652,7 @@ namespace NoConstantCondition { * ``` */ namespace NoConstructorReturn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5629,7 +5668,7 @@ namespace NoConstructorReturn { * ``` */ namespace NoContinue { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5645,7 +5684,7 @@ namespace NoContinue { * ``` */ namespace NoControlRegex { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5661,7 +5700,7 @@ namespace NoControlRegex { * ``` */ namespace NoDebugger { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5677,7 +5716,7 @@ namespace NoDebugger { * ``` */ namespace NoDeleteVar { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5694,7 +5733,7 @@ namespace NoDeleteVar { * ``` */ namespace NoDivRegex { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5710,7 +5749,7 @@ namespace NoDivRegex { * ``` */ namespace NoDupeArgs { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5726,7 +5765,7 @@ namespace NoDupeArgs { * ``` */ namespace NoDupeClassMembers { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5742,7 +5781,7 @@ namespace NoDupeClassMembers { * ``` */ namespace NoDupeElseIf { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5758,7 +5797,7 @@ namespace NoDupeElseIf { * ``` */ namespace NoDupeKeys { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5774,7 +5813,7 @@ namespace NoDupeKeys { * ``` */ namespace NoDuplicateCase { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5812,8 +5851,9 @@ namespace NoDuplicateImports { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5852,8 +5892,9 @@ namespace NoElseReturn { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5892,8 +5933,9 @@ namespace NoEmpty { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5909,7 +5951,7 @@ namespace NoEmpty { * ``` */ namespace NoEmptyCharacterClass { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5973,8 +6015,9 @@ namespace NoEmptyFunction { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6012,8 +6055,9 @@ namespace NoEmptyPattern { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6029,7 +6073,7 @@ namespace NoEmptyPattern { * ``` */ namespace NoEmptyStaticBlock { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6045,7 +6089,7 @@ namespace NoEmptyStaticBlock { * ``` */ namespace NoEqNull { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6083,8 +6127,9 @@ namespace NoEval { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6100,7 +6145,7 @@ namespace NoEval { * ``` */ namespace NoExAssign { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6142,8 +6187,9 @@ namespace NoExtendNative { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6160,7 +6206,7 @@ namespace NoExtendNative { * ``` */ namespace NoExtraBind { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6216,8 +6262,9 @@ namespace NoExtraBooleanCast { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6234,7 +6281,7 @@ namespace NoExtraBooleanCast { * ``` */ namespace NoExtraLabel { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6382,8 +6429,9 @@ namespace NoFallthrough { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6417,7 +6465,7 @@ namespace NoFloatingDecimal { * ``` */ namespace NoFuncAssign { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6459,8 +6507,9 @@ namespace NoGlobalAssign { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6527,8 +6576,9 @@ namespace NoImplicitCoercion { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6566,8 +6616,9 @@ namespace NoImplicitGlobals { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6583,7 +6634,7 @@ namespace NoImplicitGlobals { * ``` */ namespace NoImpliedEval { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6599,7 +6650,7 @@ namespace NoImpliedEval { * ``` */ namespace NoImportAssign { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6637,8 +6688,9 @@ namespace NoInlineComments { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6687,9 +6739,10 @@ namespace NoInnerDeclarations { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -6730,8 +6783,9 @@ namespace NoInvalidRegexp { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6769,8 +6823,9 @@ namespace NoInvalidThis { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6824,8 +6879,9 @@ namespace NoIrregularWhitespace { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6841,7 +6897,7 @@ namespace NoIrregularWhitespace { * ``` */ namespace NoIterator { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6857,7 +6913,7 @@ namespace NoIterator { * ``` */ namespace NoLabelVar { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6899,8 +6955,9 @@ namespace NoLabels { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6916,7 +6973,7 @@ namespace NoLabels { * ``` */ namespace NoLoneBlocks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6933,7 +6990,7 @@ namespace NoLoneBlocks { * ``` */ namespace NoLonelyIf { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6950,7 +7007,7 @@ namespace NoLonelyIf { * ``` */ namespace NoLoopFunc { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6966,7 +7023,7 @@ namespace NoLoopFunc { * ``` */ namespace NoLossOfPrecision { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7041,8 +7098,9 @@ namespace NoMagicNumbers { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7083,8 +7141,9 @@ namespace NoMisleadingCharacterClass { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7273,8 +7332,9 @@ namespace NoMultiAssign { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7335,7 +7395,7 @@ namespace NoMultiSpaces { * ``` */ namespace NoMultiStr { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7436,7 +7496,7 @@ namespace NoNativeReassign { * ``` */ namespace NoNegatedCondition { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7469,7 +7529,7 @@ namespace NoNegatedInLhs { * ``` */ namespace NoNestedTernary { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7485,7 +7545,7 @@ namespace NoNestedTernary { * ``` */ namespace NoNew { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7501,7 +7561,7 @@ namespace NoNew { * ``` */ namespace NoNewFunc { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7517,7 +7577,7 @@ namespace NoNewFunc { * ``` */ namespace NoNewNativeNonconstructor { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7584,7 +7644,7 @@ namespace NoNewSymbol { * ``` */ namespace NoNewWrappers { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7601,7 +7661,7 @@ namespace NoNewWrappers { * ``` */ namespace NoNonoctalDecimalEscape { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7617,7 +7677,7 @@ namespace NoNonoctalDecimalEscape { * ``` */ namespace NoObjCalls { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7634,7 +7694,7 @@ namespace NoObjCalls { * ``` */ namespace NoObjectConstructor { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7650,7 +7710,7 @@ namespace NoObjectConstructor { * ``` */ namespace NoOctal { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7666,7 +7726,7 @@ namespace NoOctal { * ``` */ namespace NoOctalEscape { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7741,8 +7801,9 @@ namespace NoParamReassign { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7797,8 +7858,9 @@ namespace NoPlusplus { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7871,8 +7933,9 @@ namespace NoPromiseExecutorReturn { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7888,7 +7951,7 @@ namespace NoPromiseExecutorReturn { * ``` */ namespace NoProto { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7905,7 +7968,7 @@ namespace NoProto { * ``` */ namespace NoPrototypeBuiltins { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7943,8 +8006,9 @@ namespace NoRedeclare { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7961,7 +8025,7 @@ namespace NoRedeclare { * ``` */ namespace NoRegexSpaces { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8061,8 +8125,9 @@ namespace NoRestrictedExports { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8119,8 +8184,9 @@ namespace NoRestrictedGlobals { )[]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8368,8 +8434,9 @@ namespace NoRestrictedImports { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8539,8 +8606,9 @@ namespace NoRestrictedProperties { )[]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8597,8 +8665,9 @@ namespace NoRestrictedSyntax { )[]; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8631,8 +8700,9 @@ namespace NoReturnAssign { export type Options = 'always' | 'except-parens'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8666,7 +8736,7 @@ namespace NoReturnAwait { * ``` */ namespace NoScriptUrl { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8704,8 +8774,9 @@ namespace NoSelfAssign { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8721,7 +8792,7 @@ namespace NoSelfAssign { * ``` */ namespace NoSelfCompare { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8759,8 +8830,9 @@ namespace NoSequences { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8776,7 +8848,7 @@ namespace NoSequences { * ``` */ namespace NoSetterReturn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8834,8 +8906,9 @@ namespace NoShadow { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8851,7 +8924,7 @@ namespace NoShadow { * ``` */ namespace NoShadowRestrictedNames { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8886,7 +8959,7 @@ namespace NoSpacedFunc { * ``` */ namespace NoSparseArrays { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8972,7 +9045,7 @@ namespace NoTabs { * ``` */ namespace NoTemplateCurlyInString { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8988,7 +9061,7 @@ namespace NoTemplateCurlyInString { * ``` */ namespace NoTernary { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9004,7 +9077,7 @@ namespace NoTernary { * ``` */ namespace NoThisBeforeSuper { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9020,7 +9093,7 @@ namespace NoThisBeforeSuper { * ``` */ namespace NoThrowLiteral { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9099,8 +9172,9 @@ namespace NoUndef { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9117,7 +9191,7 @@ namespace NoUndef { * ``` */ namespace NoUndefInit { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9133,7 +9207,7 @@ namespace NoUndefInit { * ``` */ namespace NoUndefined { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9206,8 +9280,9 @@ namespace NoUnderscoreDangle { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9223,7 +9298,7 @@ namespace NoUnderscoreDangle { * ``` */ namespace NoUnexpectedMultiline { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9239,7 +9314,7 @@ namespace NoUnexpectedMultiline { * ``` */ namespace NoUnmodifiedLoopCondition { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9278,8 +9353,9 @@ namespace NoUnneededTernary { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9296,7 +9372,7 @@ namespace NoUnneededTernary { * ``` */ namespace NoUnreachable { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9350,8 +9426,9 @@ namespace NoUnreachableLoop { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9367,7 +9444,7 @@ namespace NoUnreachableLoop { * ``` */ namespace NoUnsafeFinally { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9406,8 +9483,9 @@ namespace NoUnsafeNegation { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9446,8 +9524,9 @@ namespace NoUnsafeOptionalChaining { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9497,8 +9576,9 @@ namespace NoUnusedExpressions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9515,7 +9595,7 @@ namespace NoUnusedExpressions { * ``` */ namespace NoUnusedLabels { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9531,7 +9611,7 @@ namespace NoUnusedLabels { * ``` */ namespace NoUnusedPrivateClassMembers { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9629,8 +9709,9 @@ namespace NoUnusedVars { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9691,8 +9772,9 @@ namespace NoUseBeforeDefine { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9708,7 +9790,7 @@ namespace NoUseBeforeDefine { * ``` */ namespace NoUselessAssignment { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9724,7 +9806,7 @@ namespace NoUselessAssignment { * ``` */ namespace NoUselessBackreference { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9740,7 +9822,7 @@ namespace NoUselessBackreference { * ``` */ namespace NoUselessCall { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9756,7 +9838,7 @@ namespace NoUselessCall { * ``` */ namespace NoUselessCatch { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9795,8 +9877,9 @@ namespace NoUselessComputedKey { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9812,7 +9895,7 @@ namespace NoUselessComputedKey { * ``` */ namespace NoUselessConcat { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9829,7 +9912,7 @@ namespace NoUselessConcat { * ``` */ namespace NoUselessConstructor { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9846,7 +9929,7 @@ namespace NoUselessConstructor { * ``` */ namespace NoUselessEscape { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9894,8 +9977,9 @@ namespace NoUselessRename { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9912,7 +9996,7 @@ namespace NoUselessRename { * ``` */ namespace NoUselessReturn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9929,7 +10013,7 @@ namespace NoUselessReturn { * ``` */ namespace NoVar { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -9967,8 +10051,9 @@ namespace NoVoid { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -10027,8 +10112,9 @@ namespace NoWarningComments { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -10062,7 +10148,7 @@ namespace NoWhitespaceBeforeProperty { * ``` */ namespace NoWith { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -10516,8 +10602,9 @@ namespace ObjectShorthand { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -10619,8 +10706,9 @@ namespace OneVar { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -10686,8 +10774,9 @@ namespace OperatorAssignment { export type Options = 'always' | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -10992,8 +11081,9 @@ namespace PreferArrowCallback { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -11040,8 +11130,9 @@ namespace PreferConst { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -11142,9 +11233,10 @@ namespace PreferDestructuring { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -11161,7 +11253,7 @@ namespace PreferDestructuring { * ``` */ namespace PreferExponentiationOperator { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11178,7 +11270,7 @@ namespace PreferExponentiationOperator { * ``` */ namespace PreferNamedCaptureGroup { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11196,7 +11288,7 @@ namespace PreferNamedCaptureGroup { * ``` */ namespace PreferNumericLiterals { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11214,7 +11306,7 @@ namespace PreferNumericLiterals { * ``` */ namespace PreferObjectHasOwn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11232,7 +11324,7 @@ namespace PreferObjectHasOwn { * ``` */ namespace PreferObjectSpread { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11270,8 +11362,9 @@ namespace PreferPromiseRejectErrors { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -11360,8 +11453,9 @@ namespace PreferRegexLiterals { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -11377,7 +11471,7 @@ namespace PreferRegexLiterals { * ``` */ namespace PreferRestParams { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11393,7 +11487,7 @@ namespace PreferRestParams { * ``` */ namespace PreferSpread { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11410,7 +11504,7 @@ namespace PreferSpread { * ``` */ namespace PreferTemplate { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11571,8 +11665,9 @@ namespace Radix { export type Options = 'always' | 'as-needed'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -11611,8 +11706,9 @@ namespace RequireAtomicUpdates { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -11629,7 +11725,7 @@ namespace RequireAtomicUpdates { * ``` */ namespace RequireAwait { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11671,8 +11767,9 @@ namespace RequireUnicodeRegexp { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -11688,7 +11785,7 @@ namespace RequireUnicodeRegexp { * ``` */ namespace RequireYield { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -11936,8 +12033,9 @@ namespace SortImports { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -12000,9 +12098,10 @@ namespace SortKeys { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -12041,8 +12140,9 @@ namespace SortVars { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -12426,8 +12526,9 @@ namespace Strict { export type Options = 'function' | 'global' | 'never' | 'safe'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -12483,7 +12584,7 @@ namespace SwitchColonSpacing { * ``` */ namespace SymbolDescription { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -12581,8 +12682,9 @@ namespace UnicodeBom { export type Options = 'always' | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -12625,8 +12727,9 @@ namespace UseIsnan { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -12665,8 +12768,9 @@ namespace ValidTypeof { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -12682,7 +12786,7 @@ namespace ValidTypeof { * ``` */ namespace VarsOnTop { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -12844,9 +12948,10 @@ namespace Yoda { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } export type EslintRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-security-rules.mts b/packages/eslint-configs/src/types/rules/eslint-security-rules.mts index 7cf7306a3a..36c644396b 100644 --- a/packages/eslint-configs/src/types/rules/eslint-security-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-security-rules.mts @@ -16,7 +16,7 @@ import { type Linter } from 'eslint'; * ``` */ namespace DetectUnsafeRegex { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -34,7 +34,7 @@ namespace DetectUnsafeRegex { * ``` */ namespace DetectNonLiteralRegexp { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -52,7 +52,7 @@ namespace DetectNonLiteralRegexp { * ``` */ namespace DetectNonLiteralRequire { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -70,7 +70,7 @@ namespace DetectNonLiteralRequire { * ``` */ namespace DetectNonLiteralFsFilename { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -88,7 +88,7 @@ namespace DetectNonLiteralFsFilename { * ``` */ namespace DetectEvalWithExpression { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -106,7 +106,7 @@ namespace DetectEvalWithExpression { * ``` */ namespace DetectPseudoRandomBytes { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -124,7 +124,7 @@ namespace DetectPseudoRandomBytes { * ``` */ namespace DetectPossibleTimingAttacks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -141,7 +141,7 @@ namespace DetectPossibleTimingAttacks { * ``` */ namespace DetectNoCsrfBeforeMethodOverride { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -158,7 +158,7 @@ namespace DetectNoCsrfBeforeMethodOverride { * ``` */ namespace DetectBufferNoassert { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -175,7 +175,7 @@ namespace DetectBufferNoassert { * ``` */ namespace DetectChildProcess { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -193,7 +193,7 @@ namespace DetectChildProcess { * ``` */ namespace DetectDisableMustacheEscape { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -210,7 +210,7 @@ namespace DetectDisableMustacheEscape { * ``` */ namespace DetectObjectInjection { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -228,7 +228,7 @@ namespace DetectObjectInjection { * ``` */ namespace DetectNewBuffer { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -246,7 +246,7 @@ namespace DetectNewBuffer { * ``` */ namespace DetectBidiCharacters { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } export type EslintSecurityRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-strict-dependencies-rules.mts b/packages/eslint-configs/src/types/rules/eslint-strict-dependencies-rules.mts index db9c39cc33..27f7f7b8cc 100644 --- a/packages/eslint-configs/src/types/rules/eslint-strict-dependencies-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-strict-dependencies-rules.mts @@ -1,5 +1,6 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; namespace StrictDependencies { /** @@ -67,9 +68,10 @@ namespace StrictDependencies { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } export type EslintStrictDependenciesRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-testing-library-rules.mts b/packages/eslint-configs/src/types/rules/eslint-testing-library-rules.mts index 1ee9587222..e50c811ca3 100644 --- a/packages/eslint-configs/src/types/rules/eslint-testing-library-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-testing-library-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce promises from async event methods are handled @@ -62,8 +66,9 @@ namespace AwaitAsyncEvents { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -78,7 +83,7 @@ namespace AwaitAsyncEvents { * ``` */ namespace AwaitAsyncQueries { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -93,7 +98,7 @@ namespace AwaitAsyncQueries { * ``` */ namespace AwaitAsyncUtils { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -153,8 +158,9 @@ namespace ConsistentDataTestid { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -206,8 +212,9 @@ namespace NoAwaitSyncEvents { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -222,7 +229,7 @@ namespace NoAwaitSyncEvents { * ``` */ namespace NoAwaitSyncQueries { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -237,7 +244,7 @@ namespace NoAwaitSyncQueries { * ``` */ namespace NoContainer { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -302,8 +309,9 @@ namespace NoDebuggingUtils { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -333,8 +341,9 @@ namespace NoDomImport { export type Options = string; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -350,7 +359,7 @@ namespace NoDomImport { * ``` */ namespace NoGlobalRegexpFlagInQuery { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -365,7 +374,7 @@ namespace NoGlobalRegexpFlagInQuery { * ``` */ namespace NoManualCleanup { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -402,8 +411,9 @@ namespace NoNodeAccess { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -418,7 +428,7 @@ namespace NoNodeAccess { * ``` */ namespace NoPromiseInFireEvent { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -459,8 +469,9 @@ namespace NoRenderInLifecycle { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -497,8 +508,9 @@ namespace NoUnnecessaryAct { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -513,7 +525,7 @@ namespace NoUnnecessaryAct { * ``` */ namespace NoWaitForMultipleAssertions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -528,7 +540,7 @@ namespace NoWaitForMultipleAssertions { * ``` */ namespace NoWaitForSideEffects { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -543,7 +555,7 @@ namespace NoWaitForSideEffects { * ``` */ namespace NoWaitForSnapshot { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -594,8 +606,9 @@ namespace PreferExplicitAssert { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -612,7 +625,7 @@ namespace PreferExplicitAssert { * ``` */ namespace PreferFindBy { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -627,7 +640,7 @@ namespace PreferFindBy { * ``` */ namespace PreferImplicitAssert { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -669,8 +682,9 @@ namespace PreferPresenceQueries { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -685,7 +699,7 @@ namespace PreferPresenceQueries { * ``` */ namespace PreferQueryByDisappearance { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -742,8 +756,9 @@ namespace PreferQueryMatchers { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -758,7 +773,7 @@ namespace PreferQueryMatchers { * ``` */ namespace PreferScreenQueries { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -795,8 +810,9 @@ namespace PreferUserEvent { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -811,7 +827,7 @@ namespace PreferUserEvent { * ``` */ namespace RenderResultNamingConvention { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } export type EslintTestingLibraryRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts b/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts index cb6f948a4a..0c14a58984 100644 --- a/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts @@ -14,7 +14,7 @@ import { type Linter } from 'eslint'; * ``` */ namespace RequireStrictMode { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -30,7 +30,7 @@ namespace RequireStrictMode { * ``` */ namespace NoUnsafeTypeAssertion { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -46,7 +46,7 @@ namespace NoUnsafeTypeAssertion { * ``` */ namespace NoUnsafeReadonlyMutableAssignment { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -62,7 +62,7 @@ namespace NoUnsafeReadonlyMutableAssignment { * ``` */ namespace NoUnsafeMutableReadonlyAssignment { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -78,7 +78,7 @@ namespace NoUnsafeMutableReadonlyAssignment { * ``` */ namespace NoEnums { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -94,7 +94,7 @@ namespace NoEnums { * ``` */ namespace NoPartialUrlConstructor { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -110,7 +110,7 @@ namespace NoPartialUrlConstructor { * ``` */ namespace NoPartialDivision { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -126,7 +126,7 @@ namespace NoPartialDivision { * ``` */ namespace NoPartialStringNormalize { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -142,7 +142,7 @@ namespace NoPartialStringNormalize { * ``` */ namespace NoPrematureFpTsEffects { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -158,7 +158,7 @@ namespace NoPrematureFpTsEffects { * ``` */ namespace NoNestedFpTsEffects { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -174,7 +174,7 @@ namespace NoNestedFpTsEffects { * ``` */ namespace NoPartialArrayReduce { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -190,7 +190,7 @@ namespace NoPartialArrayReduce { * ``` */ namespace NoHiddenTypeAssertions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } export type EslintTotalFunctionsRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts b/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts index afb415c47d..8391e1263e 100644 --- a/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts @@ -12,7 +12,7 @@ import { type Linter } from 'eslint'; * ``` */ namespace ImportStar { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } export type EslintTreeShakableRules = { diff --git a/packages/eslint-configs/src/types/rules/eslint-unicorn-rules.mts b/packages/eslint-configs/src/types/rules/eslint-unicorn-rules.mts index db18e16c66..45a442dc62 100644 --- a/packages/eslint-configs/src/types/rules/eslint-unicorn-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-unicorn-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Improve regexes by making them shorter, consistent, and safer. @@ -41,8 +45,9 @@ namespace BetterRegex { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -86,8 +91,9 @@ namespace CatchErrorName { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -105,7 +111,7 @@ namespace CatchErrorName { * ``` */ namespace ConsistentDestructuring { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -122,7 +128,7 @@ namespace ConsistentDestructuring { * ``` */ namespace ConsistentEmptyArraySpread { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -140,7 +146,7 @@ namespace ConsistentEmptyArraySpread { * ``` */ namespace ConsistentExistenceIndexCheck { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -179,8 +185,9 @@ namespace ConsistentFunctionScoping { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -197,7 +204,7 @@ namespace ConsistentFunctionScoping { * ``` */ namespace CustomErrorDefinition { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -214,7 +221,7 @@ namespace CustomErrorDefinition { * ``` */ namespace EmptyBraceSpaces { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -230,7 +237,7 @@ namespace EmptyBraceSpaces { * ``` */ namespace ErrorMessage { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -247,7 +254,7 @@ namespace ErrorMessage { * ``` */ namespace EscapeCase { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -308,8 +315,9 @@ namespace ExpiringTodoComments { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -353,8 +361,9 @@ namespace ExplicitLengthCheck { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -449,8 +458,9 @@ namespace FilenameCase { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -546,8 +556,9 @@ namespace ImportStyle { >; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -565,7 +576,7 @@ namespace ImportStyle { * ``` */ namespace NewForBuiltins { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -581,7 +592,7 @@ namespace NewForBuiltins { * ``` */ namespace NoAbusiveEslintDisable { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -598,7 +609,7 @@ namespace NoAbusiveEslintDisable { * ``` */ namespace NoAnonymousDefaultExport { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -615,7 +626,7 @@ namespace NoAnonymousDefaultExport { * ``` */ namespace NoArrayCallbackReference { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -633,7 +644,7 @@ namespace NoArrayCallbackReference { * ``` */ namespace NoArrayForEach { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -651,7 +662,7 @@ namespace NoArrayForEach { * ``` */ namespace NoArrayMethodThisArgument { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -692,8 +703,9 @@ namespace NoArrayPushPush { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -732,8 +744,9 @@ namespace NoArrayReduce { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -750,7 +763,7 @@ namespace NoArrayReduce { * ``` */ namespace NoAwaitExpressionMember { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -767,7 +780,7 @@ namespace NoAwaitExpressionMember { * ``` */ namespace NoAwaitInPromiseMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -784,7 +797,7 @@ namespace NoAwaitInPromiseMethods { * ``` */ namespace NoConsoleSpaces { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -800,7 +813,7 @@ namespace NoConsoleSpaces { * ``` */ namespace NoDocumentCookie { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -816,7 +829,7 @@ namespace NoDocumentCookie { * ``` */ namespace NoEmptyFile { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -834,7 +847,7 @@ namespace NoEmptyFile { * ``` */ namespace NoForLoop { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -851,7 +864,7 @@ namespace NoForLoop { * ``` */ namespace NoHexEscape { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -868,7 +881,7 @@ namespace NoHexEscape { * ``` */ namespace NoInstanceofArray { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -884,7 +897,7 @@ namespace NoInstanceofArray { * ``` */ namespace NoInvalidFetchOptions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -901,7 +914,7 @@ namespace NoInvalidFetchOptions { * ``` */ namespace NoInvalidRemoveEventListener { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -955,8 +968,9 @@ namespace NoKeywordPrefix { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -974,7 +988,7 @@ namespace NoKeywordPrefix { * ``` */ namespace NoLengthAsSliceEnd { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -991,7 +1005,7 @@ namespace NoLengthAsSliceEnd { * ``` */ namespace NoLonelyIf { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1007,7 +1021,7 @@ namespace NoLonelyIf { * ``` */ namespace NoMagicArrayFlatDepth { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1024,7 +1038,7 @@ namespace NoMagicArrayFlatDepth { * ``` */ namespace NoNegatedCondition { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1041,7 +1055,7 @@ namespace NoNegatedCondition { * ``` */ namespace NoNegationInEqualityCheck { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1058,7 +1072,7 @@ namespace NoNegationInEqualityCheck { * ``` */ namespace NoNestedTernary { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1076,7 +1090,7 @@ namespace NoNestedTernary { * ``` */ namespace NoNewArray { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1095,7 +1109,7 @@ namespace NoNewArray { * ``` */ namespace NoNewBuffer { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1136,8 +1150,9 @@ namespace NoNull { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1153,7 +1168,7 @@ namespace NoNull { * ``` */ namespace NoObjectAsDefaultParameter { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1169,7 +1184,7 @@ namespace NoObjectAsDefaultParameter { * ``` */ namespace NoProcessExit { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1187,7 +1202,7 @@ namespace NoProcessExit { * ``` */ namespace NoSinglePromiseInPromiseMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1204,7 +1219,7 @@ namespace NoSinglePromiseInPromiseMethods { * ``` */ namespace NoStaticOnlyClass { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1220,7 +1235,7 @@ namespace NoStaticOnlyClass { * ``` */ namespace NoThenable { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1236,7 +1251,7 @@ namespace NoThenable { * ``` */ namespace NoThisAssignment { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1277,8 +1292,9 @@ namespace NoTypeofUndefined { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1295,7 +1311,7 @@ namespace NoTypeofUndefined { * ``` */ namespace NoUnnecessaryAwait { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1346,8 +1362,9 @@ namespace NoUnnecessaryPolyfills { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1364,7 +1381,7 @@ namespace NoUnnecessaryPolyfills { * ``` */ namespace NoUnreadableArrayDestructuring { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1381,7 +1398,7 @@ namespace NoUnreadableArrayDestructuring { * ``` */ namespace NoUnreadableIife { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1397,7 +1414,7 @@ namespace NoUnreadableIife { * ``` */ namespace NoUnusedProperties { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1414,7 +1431,7 @@ namespace NoUnusedProperties { * ``` */ namespace NoUselessFallbackInSpread { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1431,7 +1448,7 @@ namespace NoUselessFallbackInSpread { * ``` */ namespace NoUselessLengthCheck { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1449,7 +1466,7 @@ namespace NoUselessLengthCheck { * ``` */ namespace NoUselessPromiseResolveReject { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1466,7 +1483,7 @@ namespace NoUselessPromiseResolveReject { * ``` */ namespace NoUselessSpread { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1483,7 +1500,7 @@ namespace NoUselessSpread { * ``` */ namespace NoUselessSwitchCase { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1526,8 +1543,9 @@ namespace NoUselessUndefined { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1544,7 +1562,7 @@ namespace NoUselessUndefined { * ``` */ namespace NoZeroFractions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1561,7 +1579,7 @@ namespace NoZeroFractions { * ``` */ namespace NumberLiteralCase { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1697,8 +1715,9 @@ namespace NumericSeparatorsStyle { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1742,8 +1761,9 @@ namespace PreferAddEventListener { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1785,8 +1805,9 @@ namespace PreferArrayFind { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1803,7 +1824,7 @@ namespace PreferArrayFind { * ``` */ namespace PreferArrayFlatMap { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1843,8 +1864,9 @@ namespace PreferArrayFlat { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1863,7 +1885,7 @@ namespace PreferArrayFlat { * ``` */ namespace PreferArrayIndexOf { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1882,7 +1904,7 @@ namespace PreferArrayIndexOf { * ``` */ namespace PreferArraySome { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1928,8 +1950,9 @@ namespace PreferAt { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1946,7 +1969,7 @@ namespace PreferAt { * ``` */ namespace PreferBlobReadingMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1964,7 +1987,7 @@ namespace PreferBlobReadingMethods { * ``` */ namespace PreferCodePoint { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1981,7 +2004,7 @@ namespace PreferCodePoint { * ``` */ namespace PreferDateNow { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1999,7 +2022,7 @@ namespace PreferDateNow { * ``` */ namespace PreferDefaultParameters { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2016,7 +2039,7 @@ namespace PreferDefaultParameters { * ``` */ namespace PreferDomNodeAppend { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2033,7 +2056,7 @@ namespace PreferDomNodeAppend { * ``` */ namespace PreferDomNodeDataset { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2051,7 +2074,7 @@ namespace PreferDomNodeDataset { * ``` */ namespace PreferDomNodeRemove { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2068,7 +2091,7 @@ namespace PreferDomNodeRemove { * ``` */ namespace PreferDomNodeTextContent { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2084,7 +2107,7 @@ namespace PreferDomNodeTextContent { * ``` */ namespace PreferEventTarget { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2125,8 +2148,9 @@ namespace PreferExportFrom { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2144,7 +2168,7 @@ namespace PreferExportFrom { * ``` */ namespace PreferGlobalThis { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2163,7 +2187,7 @@ namespace PreferGlobalThis { * ``` */ namespace PreferIncludes { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2180,7 +2204,7 @@ namespace PreferIncludes { * ``` */ namespace PreferJsonParseBuffer { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2197,7 +2221,7 @@ namespace PreferJsonParseBuffer { * ``` */ namespace PreferKeyboardEventKey { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2214,7 +2238,7 @@ namespace PreferKeyboardEventKey { * ``` */ namespace PreferLogicalOperatorOverTernary { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2231,7 +2255,7 @@ namespace PreferLogicalOperatorOverTernary { * ``` */ namespace PreferMathMinMax { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2249,7 +2273,7 @@ namespace PreferMathMinMax { * ``` */ namespace PreferMathTrunc { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2268,7 +2292,7 @@ namespace PreferMathTrunc { * ``` */ namespace PreferModernDomApis { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2285,7 +2309,7 @@ namespace PreferModernDomApis { * ``` */ namespace PreferModernMathApis { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2303,7 +2327,7 @@ namespace PreferModernMathApis { * ``` */ namespace PreferModule { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2320,7 +2344,7 @@ namespace PreferModule { * ``` */ namespace PreferNativeCoercionFunctions { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2337,7 +2361,7 @@ namespace PreferNativeCoercionFunctions { * ``` */ namespace PreferNegativeIndex { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2354,7 +2378,7 @@ namespace PreferNegativeIndex { * ``` */ namespace PreferNodeProtocol { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2400,8 +2424,9 @@ namespace PreferNumberProperties { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2442,8 +2467,9 @@ namespace PreferObjectFromEntries { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2460,7 +2486,7 @@ namespace PreferObjectFromEntries { * ``` */ namespace PreferOptionalCatchBinding { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2477,7 +2503,7 @@ namespace PreferOptionalCatchBinding { * ``` */ namespace PreferPrototypeMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2496,7 +2522,7 @@ namespace PreferPrototypeMethods { * ``` */ namespace PreferQuerySelector { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2513,7 +2539,7 @@ namespace PreferQuerySelector { * ``` */ namespace PreferReflectApply { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2531,7 +2557,7 @@ namespace PreferReflectApply { * ``` */ namespace PreferRegexpTest { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2550,7 +2576,7 @@ namespace PreferRegexpTest { * ``` */ namespace PreferSetHas { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2567,7 +2593,7 @@ namespace PreferSetHas { * ``` */ namespace PreferSetSize { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2586,7 +2612,7 @@ namespace PreferSetSize { * ``` */ namespace PreferSpread { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2603,7 +2629,7 @@ namespace PreferSpread { * ``` */ namespace PreferStringRaw { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2620,7 +2646,7 @@ namespace PreferStringRaw { * ``` */ namespace PreferStringReplaceAll { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2637,7 +2663,7 @@ namespace PreferStringReplaceAll { * ``` */ namespace PreferStringSlice { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2655,7 +2681,7 @@ namespace PreferStringSlice { * ``` */ namespace PreferStringStartsEndsWith { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2673,7 +2699,7 @@ namespace PreferStringStartsEndsWith { * ``` */ namespace PreferStringTrimStartEnd { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2713,8 +2739,9 @@ namespace PreferStructuredClone { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2767,8 +2794,9 @@ namespace PreferSwitch { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2803,8 +2831,9 @@ namespace PreferTernary { export type Options = 'always' | 'only-single-line'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2821,7 +2850,7 @@ namespace PreferTernary { * ``` */ namespace PreferTopLevelAwait { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2838,7 +2867,7 @@ namespace PreferTopLevelAwait { * ``` */ namespace PreferTypeError { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -2956,8 +2985,9 @@ namespace PreventAbbreviations { export type BooleanObject = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -2993,8 +3023,9 @@ namespace RelativeUrlStyle { export type Options = 'always' | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3011,7 +3042,7 @@ namespace RelativeUrlStyle { * ``` */ namespace RequireArrayJoinSeparator { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3028,7 +3059,7 @@ namespace RequireArrayJoinSeparator { * ``` */ namespace RequireNumberToFixedDigitsArgument { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3045,7 +3076,7 @@ namespace RequireNumberToFixedDigitsArgument { * ``` */ namespace RequirePostMessageTargetOrigin { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3118,8 +3149,9 @@ namespace StringContent { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3153,8 +3185,9 @@ namespace SwitchCaseBraces { export type Options = 'always' | 'avoid'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3234,8 +3267,9 @@ namespace TemplateIndent { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -3253,7 +3287,7 @@ namespace TemplateIndent { * ``` */ namespace TextEncodingIdentifierCase { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -3270,7 +3304,7 @@ namespace TextEncodingIdentifierCase { * ``` */ namespace ThrowNewError { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** diff --git a/packages/eslint-configs/src/types/rules/eslint-vitest-rules.mts b/packages/eslint-configs/src/types/rules/eslint-vitest-rules.mts index 980e6057e6..e351061fda 100644 --- a/packages/eslint-configs/src/types/rules/eslint-vitest-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-vitest-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Enforce lowercase titles @@ -66,8 +70,9 @@ namespace PreferLowercaseTitle { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -105,8 +110,9 @@ namespace MaxNestedDescribe { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -123,7 +129,7 @@ namespace MaxNestedDescribe { * ``` */ namespace NoIdenticalTitle { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -163,8 +169,9 @@ namespace NoFocusedTests { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -180,7 +187,7 @@ namespace NoFocusedTests { * ``` */ namespace NoConditionalTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -230,8 +237,9 @@ namespace ExpectExpect { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -282,8 +290,9 @@ namespace ConsistentTestIt { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -300,7 +309,7 @@ namespace ConsistentTestIt { * ``` */ namespace PreferToBe { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -344,8 +353,9 @@ namespace NoHooks { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -381,8 +391,9 @@ namespace NoRestrictedViMethods { export type Options = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -427,8 +438,9 @@ namespace ConsistentTestFilename { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -467,8 +479,9 @@ namespace MaxExpects { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -486,7 +499,7 @@ namespace MaxExpects { * ``` */ namespace NoAliasMethods { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -503,7 +516,7 @@ namespace NoAliasMethods { * ``` */ namespace NoCommentedOutTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -520,7 +533,7 @@ namespace NoCommentedOutTests { * ``` */ namespace NoConditionalExpect { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -537,7 +550,7 @@ namespace NoConditionalExpect { * ``` */ namespace NoConditionalInTest { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -553,7 +566,7 @@ namespace NoConditionalInTest { * ``` */ namespace NoDisabledTests { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -588,7 +601,7 @@ namespace NoDoneCallback { * ``` */ namespace NoDuplicateHooks { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -637,8 +650,9 @@ namespace NoLargeSnapshots { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -655,7 +669,7 @@ namespace NoLargeSnapshots { * ``` */ namespace NoInterpolationInSnapshots { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -671,7 +685,7 @@ namespace NoInterpolationInSnapshots { * ``` */ namespace NoMocksImport { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -707,8 +721,9 @@ namespace NoRestrictedMatchers { export type Options = Readonly>; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -748,8 +763,9 @@ namespace NoStandaloneExpect { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -766,7 +782,7 @@ namespace NoStandaloneExpect { * ``` */ namespace NoTestPrefixes { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -782,7 +798,7 @@ namespace NoTestPrefixes { * ``` */ namespace NoTestReturnStatement { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -799,7 +815,7 @@ namespace NoTestReturnStatement { * ``` */ namespace NoImportNodeTest { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -816,7 +832,7 @@ namespace NoImportNodeTest { * ``` */ namespace PreferCalledWith { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -919,8 +935,9 @@ namespace ValidTitle { >; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -976,8 +993,9 @@ namespace ValidExpect { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -994,7 +1012,7 @@ namespace ValidExpect { * ``` */ namespace PreferToBeFalsy { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1011,7 +1029,7 @@ namespace PreferToBeFalsy { * ``` */ namespace PreferToBeObject { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1028,7 +1046,7 @@ namespace PreferToBeObject { * ``` */ namespace PreferToBeTruthy { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1045,7 +1063,7 @@ namespace PreferToBeTruthy { * ``` */ namespace PreferToHaveLength { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1062,7 +1080,7 @@ namespace PreferToHaveLength { * ``` */ namespace PreferEqualityMatcher { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1079,7 +1097,7 @@ namespace PreferEqualityMatcher { * ``` */ namespace PreferStrictEqual { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1096,7 +1114,7 @@ namespace PreferStrictEqual { * ``` */ namespace PreferExpectResolves { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1112,7 +1130,7 @@ namespace PreferExpectResolves { * ``` */ namespace PreferEach { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1128,7 +1146,7 @@ namespace PreferEach { * ``` */ namespace PreferHooksOnTop { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1144,7 +1162,7 @@ namespace PreferHooksOnTop { * ``` */ namespace PreferHooksInOrder { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1160,7 +1178,7 @@ namespace PreferHooksInOrder { * ``` */ namespace RequireLocalTestContextForConcurrentSnapshots { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1177,7 +1195,7 @@ namespace RequireLocalTestContextForConcurrentSnapshots { * ``` */ namespace PreferMockPromiseShorthand { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1211,8 +1229,9 @@ namespace PreferSnapshotHint { export type Options = 'always' | 'multi'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1228,7 +1247,7 @@ namespace PreferSnapshotHint { * ``` */ namespace ValidDescribeCallback { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1267,8 +1286,9 @@ namespace RequireTopLevelDescribe { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1284,7 +1304,7 @@ namespace RequireTopLevelDescribe { * ``` */ namespace RequireToThrowMessage { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1325,8 +1345,9 @@ namespace RequireHook { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1343,7 +1364,7 @@ namespace RequireHook { * ``` */ namespace PreferTodo { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1360,7 +1381,7 @@ namespace PreferTodo { * ``` */ namespace PreferSpyOn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1377,7 +1398,7 @@ namespace PreferSpyOn { * ``` */ namespace PreferComparisonMatcher { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1394,7 +1415,7 @@ namespace PreferComparisonMatcher { * ``` */ namespace PreferToContain { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -1441,8 +1462,9 @@ namespace PreferExpectAssertions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } export type EslintVitestRules = { diff --git a/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts b/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts index bb1042d888..b328351f9e 100644 --- a/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts +++ b/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts @@ -1,8 +1,12 @@ /* cSpell:disable */ import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; -type SpreadOptionsIfIsArray = - T[1] extends readonly unknown[] ? readonly [Linter.RuleSeverity, ...T[1]] : T; +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; /** * Require that function overload signatures be consecutive @@ -17,7 +21,7 @@ type SpreadOptionsIfIsArray = * ``` */ namespace AdjacentOverloadSignatures { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -77,8 +81,9 @@ namespace ArrayType { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -96,7 +101,7 @@ namespace ArrayType { * ``` */ namespace AwaitThenable { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -189,8 +194,9 @@ namespace BanTsComment { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -207,7 +213,7 @@ namespace BanTsComment { * ``` */ namespace BanTslintComment { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -244,8 +250,9 @@ namespace ClassLiteralPropertyStyle { export type Options = 'fields' | 'getters'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -325,8 +332,9 @@ namespace ClassMethodsUseThis { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -364,8 +372,9 @@ namespace ConsistentGenericConstructors { export type Options = 'constructor' | 'type-annotation'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -403,8 +412,9 @@ namespace ConsistentIndexedObjectStyle { export type Options = 'index-signature' | 'record'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -442,8 +452,9 @@ namespace ConsistentReturn { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -548,8 +559,9 @@ namespace ConsistentTypeAssertions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -586,8 +598,9 @@ namespace ConsistentTypeDefinitions { export type Options = 'interface' | 'type'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -631,8 +644,9 @@ namespace ConsistentTypeExports { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -695,8 +709,9 @@ namespace ConsistentTypeImports { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -711,7 +726,7 @@ namespace ConsistentTypeImports { * ``` */ namespace DefaultParamLast { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -791,8 +806,9 @@ namespace DotNotation { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -891,8 +907,9 @@ namespace ExplicitFunctionReturnType { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1004,8 +1021,9 @@ namespace ExplicitMemberAccessibility { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1086,8 +1104,9 @@ namespace ExplicitModuleBoundaryTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1153,8 +1172,9 @@ namespace InitDeclarations { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1207,8 +1227,9 @@ namespace MaxParams { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1766,8 +1787,9 @@ namespace MemberOrdering { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -1801,8 +1823,9 @@ namespace MethodSignatureStyle { export type Options = 'method' | 'property'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4052,8 +4075,9 @@ namespace NamingConvention { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4070,7 +4094,7 @@ namespace NamingConvention { * ``` */ namespace NoArrayConstructor { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4088,7 +4112,7 @@ namespace NoArrayConstructor { * ``` */ namespace NoArrayDelete { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4133,8 +4157,9 @@ namespace NoBaseToString { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4151,7 +4176,7 @@ namespace NoBaseToString { * ``` */ namespace NoConfusingNonNullAssertion { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4212,8 +4237,9 @@ namespace NoConfusingVoidExpression { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4377,8 +4403,9 @@ namespace NoDeprecated { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4393,7 +4420,7 @@ namespace NoDeprecated { * ``` */ namespace NoDupeClassMembers { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4410,7 +4437,7 @@ namespace NoDupeClassMembers { * ``` */ namespace NoDuplicateEnumValues { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4458,8 +4485,9 @@ namespace NoDuplicateTypeConstituents { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4476,7 +4504,7 @@ namespace NoDuplicateTypeConstituents { * ``` */ namespace NoDynamicDelete { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4551,8 +4579,9 @@ namespace NoEmptyFunction { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4653,8 +4682,9 @@ namespace NoEmptyObjectType { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4705,8 +4735,9 @@ namespace NoExplicitAny { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -4723,7 +4754,7 @@ namespace NoExplicitAny { * ``` */ namespace NoExtraNonNullAssertion { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -4781,8 +4812,9 @@ namespace NoExtraneousClass { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5094,8 +5126,9 @@ namespace NoFloatingPromises { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5112,7 +5145,7 @@ namespace NoFloatingPromises { * ``` */ namespace NoForInArray { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5129,7 +5162,7 @@ namespace NoForInArray { * ``` */ namespace NoImpliedEval { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5146,7 +5179,7 @@ namespace NoImpliedEval { * ``` */ namespace NoImportTypeSideEffects { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5194,8 +5227,9 @@ namespace NoInferrableTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5232,8 +5266,9 @@ namespace NoInvalidThis { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5294,8 +5329,9 @@ namespace NoInvalidVoidType { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5311,7 +5347,7 @@ namespace NoInvalidVoidType { * ``` */ namespace NoLoopFunc { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5428,8 +5464,9 @@ namespace NoMagicNumbers { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5473,8 +5510,9 @@ namespace NoMeaninglessVoidOperator { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5490,7 +5528,7 @@ namespace NoMeaninglessVoidOperator { * ``` */ namespace NoMisusedNew { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5615,8 +5653,9 @@ namespace NoMisusedPromises { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5780,8 +5819,9 @@ namespace NoMisusedSpread { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5798,7 +5838,7 @@ namespace NoMisusedSpread { * ``` */ namespace NoMixedEnums { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5847,8 +5887,9 @@ namespace NoNamespace { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5866,7 +5907,7 @@ namespace NoNamespace { * ``` */ namespace NoNonNullAssertedNullishCoalescing { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5883,7 +5924,7 @@ namespace NoNonNullAssertedNullishCoalescing { * ``` */ namespace NoNonNullAssertedOptionalChain { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5900,7 +5941,7 @@ namespace NoNonNullAssertedOptionalChain { * ``` */ namespace NoNonNullAssertion { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -5948,8 +5989,9 @@ namespace NoRedeclare { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -5967,7 +6009,7 @@ namespace NoRedeclare { * ``` */ namespace NoRedundantTypeConstituents { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6016,8 +6058,9 @@ namespace NoRequireImports { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6254,8 +6297,9 @@ namespace NoRestrictedImports { | readonly []; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6356,8 +6400,9 @@ namespace NoRestrictedTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6448,8 +6493,9 @@ namespace NoShadow { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6501,8 +6547,9 @@ namespace NoThisAlias { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6637,8 +6684,9 @@ namespace NoUnnecessaryBooleanLiteralCompare { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6698,8 +6746,9 @@ namespace NoUnnecessaryCondition { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6714,7 +6763,7 @@ namespace NoUnnecessaryCondition { * ``` */ namespace NoUnnecessaryParameterPropertyAssignment { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6731,7 +6780,7 @@ namespace NoUnnecessaryParameterPropertyAssignment { * ``` */ namespace NoUnnecessaryQualifier { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6749,7 +6798,7 @@ namespace NoUnnecessaryQualifier { * ``` */ namespace NoUnnecessaryTemplateExpression { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6767,7 +6816,7 @@ namespace NoUnnecessaryTemplateExpression { * ``` */ namespace NoUnnecessaryTypeArguments { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6812,8 +6861,9 @@ namespace NoUnnecessaryTypeAssertion { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -6830,7 +6880,7 @@ namespace NoUnnecessaryTypeAssertion { * ``` */ namespace NoUnnecessaryTypeConstraint { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6848,7 +6898,7 @@ namespace NoUnnecessaryTypeConstraint { * ``` */ namespace NoUnnecessaryTypeParameters { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6865,7 +6915,7 @@ namespace NoUnnecessaryTypeParameters { * ``` */ namespace NoUnsafeArgument { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6882,7 +6932,7 @@ namespace NoUnsafeArgument { * ``` */ namespace NoUnsafeAssignment { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6899,7 +6949,7 @@ namespace NoUnsafeAssignment { * ``` */ namespace NoUnsafeCall { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6916,7 +6966,7 @@ namespace NoUnsafeCall { * ``` */ namespace NoUnsafeDeclarationMerging { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6934,7 +6984,7 @@ namespace NoUnsafeDeclarationMerging { * ``` */ namespace NoUnsafeEnumComparison { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6951,7 +7001,7 @@ namespace NoUnsafeEnumComparison { * ``` */ namespace NoUnsafeFunctionType { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6968,7 +7018,7 @@ namespace NoUnsafeFunctionType { * ``` */ namespace NoUnsafeMemberAccess { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -6985,7 +7035,7 @@ namespace NoUnsafeMemberAccess { * ``` */ namespace NoUnsafeReturn { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7001,7 +7051,7 @@ namespace NoUnsafeReturn { * ``` */ namespace NoUnsafeTypeAssertion { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7018,7 +7068,7 @@ namespace NoUnsafeTypeAssertion { * ``` */ namespace NoUnsafeUnaryMinus { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7068,8 +7118,9 @@ namespace NoUnusedExpressions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7202,8 +7253,9 @@ namespace NoUnusedVars { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7293,8 +7345,9 @@ namespace NoUseBeforeDefine { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7311,7 +7364,7 @@ namespace NoUseBeforeDefine { * ``` */ namespace NoUselessConstructor { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7328,7 +7381,7 @@ namespace NoUselessConstructor { * ``` */ namespace NoUselessEmptyExport { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7382,7 +7435,7 @@ namespace NoVarRequires { * ``` */ namespace NoWrapperObjectTypes { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7400,7 +7453,7 @@ namespace NoWrapperObjectTypes { * ``` */ namespace NonNullableTypeAssertionStyle { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7576,8 +7629,9 @@ namespace OnlyThrowError { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7652,8 +7706,9 @@ namespace ParameterProperties { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7671,7 +7726,7 @@ namespace ParameterProperties { * ``` */ namespace PreferAsConst { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7786,9 +7841,10 @@ namespace PreferDestructuring { }; export type RuleEntry = - | Linter.RuleSeverity - | readonly [Linter.RuleSeverity, Options0, Options1] - | readonly [Linter.RuleSeverity, Options0]; + | RuleSeverityWithDefaultOption + | readonly [Linter.StringSeverity, Options0, Options1] + | readonly [Linter.StringSeverity, Options0] + | 'off'; } /** @@ -7804,7 +7860,7 @@ namespace PreferDestructuring { * ``` */ namespace PreferEnumInitializers { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7823,7 +7879,7 @@ namespace PreferEnumInitializers { * ``` */ namespace PreferFind { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7839,7 +7895,7 @@ namespace PreferFind { * ``` */ namespace PreferForOf { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7856,7 +7912,7 @@ namespace PreferForOf { * ``` */ namespace PreferFunctionType { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7874,7 +7930,7 @@ namespace PreferFunctionType { * ``` */ namespace PreferIncludes { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -7915,8 +7971,9 @@ namespace PreferLiteralEnumMember { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -7934,7 +7991,7 @@ namespace PreferLiteralEnumMember { * ``` */ namespace PreferNamespaceKeyword { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8062,8 +8119,9 @@ namespace PreferNullishCoalescing { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8173,8 +8231,9 @@ namespace PreferOptionalChain { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8227,8 +8286,9 @@ namespace PreferPromiseRejectErrors { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8273,8 +8333,9 @@ namespace PreferReadonly { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8456,8 +8517,9 @@ namespace PreferReadonlyParameterTypes { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8476,7 +8538,7 @@ namespace PreferReadonlyParameterTypes { * ``` */ namespace PreferReduceTypeParameter { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8494,7 +8556,7 @@ namespace PreferReduceTypeParameter { * ``` */ namespace PreferRegexpExec { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8512,7 +8574,7 @@ namespace PreferRegexpExec { * ``` */ namespace PreferReturnThisType { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8562,8 +8624,9 @@ namespace PreferStringStartsEndsWith { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8654,8 +8717,9 @@ namespace PromiseFunctionAsync { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8673,7 +8737,7 @@ namespace PromiseFunctionAsync { * ``` */ namespace RelatedGetterSetterPairs { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8714,8 +8778,9 @@ namespace RequireArraySortCompare { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -8734,7 +8799,7 @@ namespace RequireArraySortCompare { * ``` */ namespace RequireAwait { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } /** @@ -8809,8 +8874,9 @@ namespace RestrictPlusOperands { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9016,8 +9082,9 @@ namespace RestrictTemplateExpressions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9084,8 +9151,9 @@ namespace ReturnAwait { | 'never'; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9246,8 +9314,9 @@ namespace StrictBooleanExpressions { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9315,8 +9384,9 @@ namespace SwitchExhaustivenessCheck { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9382,8 +9452,9 @@ namespace TripleSlashReference { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9482,8 +9553,9 @@ namespace Typedef { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9524,8 +9596,9 @@ namespace UnboundMethod { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9569,8 +9642,9 @@ namespace UnifiedSignatures { }; export type RuleEntry = - | Linter.RuleSeverity - | SpreadOptionsIfIsArray; + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; } /** @@ -9589,7 +9663,7 @@ namespace UnifiedSignatures { * ``` */ namespace UseUnknownInCatchCallbackVariable { - export type RuleEntry = Linter.RuleSeverity; + export type RuleEntry = Linter.StringSeverity; } export type TypeScriptEslintRules = { From a14bc58d0840c702247e0564c8dd3a705079c31c Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Tue, 11 Feb 2025 20:48:03 +0900 Subject: [PATCH 18/25] chore: update eslint rule settings --- .../src/rules/eslint-prefer-arrow-functions-rules.mts | 6 ++++-- packages/eslint-configs/src/rules/eslint-react-rules.mts | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/packages/eslint-configs/src/rules/eslint-prefer-arrow-functions-rules.mts b/packages/eslint-configs/src/rules/eslint-prefer-arrow-functions-rules.mts index 4fb9466ff5..f313278002 100644 --- a/packages/eslint-configs/src/rules/eslint-prefer-arrow-functions-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-prefer-arrow-functions-rules.mts @@ -4,10 +4,12 @@ export const eslintPreferArrowFunctionRules: EslintPreferArrowFunctionRules = { 'prefer-arrow-functions/prefer-arrow-functions': [ 'error', { + allowedNames: [], + allowObjectProperties: false, allowNamedFunctions: false, classPropertiesAllowed: false, - disallowPrototype: false, - returnStyle: 'unchanged', + disallowPrototype: true, + returnStyle: 'implicit', singleReturnOnly: false, }, ], diff --git a/packages/eslint-configs/src/rules/eslint-react-rules.mts b/packages/eslint-configs/src/rules/eslint-react-rules.mts index 461c50c501..5b1423bba1 100644 --- a/packages/eslint-configs/src/rules/eslint-react-rules.mts +++ b/packages/eslint-configs/src/rules/eslint-react-rules.mts @@ -40,10 +40,10 @@ export const eslintReactRules: EslintReactRules = { 'error', { unnamedComponents: 'arrow-function', namedComponents: 'arrow-function' }, ], // modified - 'react/hook-use-state': 'off', // disabled + 'react/hook-use-state': 'off', 'react/iframe-missing-sandbox': 'error', 'react/jsx-boolean-value': ['error', 'always'], - 'react/jsx-curly-brace-presence': 'off', // disabled + 'react/jsx-curly-brace-presence': ['error', 'always'], /** ファイル名の統一 */ 'react/jsx-filename-extension': ['error', { extensions: ['.tsx'] }], // modified From 7d884d0689574968b7e2ca62265faae37488b22a Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sat, 22 Feb 2025 17:29:06 +0900 Subject: [PATCH 19/25] fix: [eslint-configs] fix gen-rules-type command --- .../scripts/generate-rules-type-core.mts | 368 +++++++++++++ .../scripts/generate-rules-type-main.mts | 166 +----- .../scripts/generate-rules-type.mts | 515 ++++++------------ .../scripts/update-dependencies.mts | 4 +- 4 files changed, 528 insertions(+), 525 deletions(-) create mode 100644 packages/eslint-configs/scripts/generate-rules-type-core.mts diff --git a/packages/eslint-configs/scripts/generate-rules-type-core.mts b/packages/eslint-configs/scripts/generate-rules-type-core.mts new file mode 100644 index 0000000000..4eea4c6d51 --- /dev/null +++ b/packages/eslint-configs/scripts/generate-rules-type-core.mts @@ -0,0 +1,368 @@ +import { toSafeUint, toUint32 } from '@noshiro/mono-utils'; +import { type Rule } from 'eslint'; +import { builtinRules } from 'eslint/use-at-your-own-risk'; +import { type JSONSchema4 } from 'json-schema'; +import { compile, type Options } from 'json-schema-to-typescript'; +import { + deepCopy, + deepReplace, + falseToUndefined, + isArray, + toCapitalCase, + toStr, +} from './utils.mjs'; + +type Meta = DeepReadonly< + DeepPartial<{ + [K in keyof Rule.RuleMetaData]: K extends 'docs' + ? Required['docs'] & { category: string } + : Rule.RuleMetaData[K]; + }> +>; + +const generatorOption: Readonly<{ + explicitRuleDefaultOption: boolean; +}> = { + explicitRuleDefaultOption: true, +} as const; + +const RuleSeverityWithDefaultOption = 'RuleSeverityWithDefaultOption'; + +const RuleSeverity = generatorOption.explicitRuleDefaultOption + ? 'Linter.StringSeverity' + : 'Linter.RuleSeverity'; + +const compilerConfig = { + bannerComment: '', + format: false, + unknownAny: true, +} as const satisfies Partial; + +const normalizeToSchemaArray = ( + schema: DeepReadonly | undefined, +): DeepReadonly => + // schema が JSONSchema4 | JSONSchema4[] | undefined 型を満たしていない plugin があったためその問題を吸収する対応。 + typeof schema !== 'object' ? [] : isArray(schema) ? schema : [schema]; + +const removeMultiLineCommentCharacter = (str: string): string => + str.replace('/*', ' ').replace('*/', ' '); + +const metaToString = (meta: Meta | undefined): string => { + if (meta === undefined) return ''; + + const { deprecated, docs, fixable, hasSuggestions, type } = meta; + + if (docs === undefined) return ''; + + const { description, recommended, category, url } = docs; + + const keyValue: DeepReadonly<[string, boolean | string | undefined][]> = [ + ['type', type], + ['deprecated', deprecated], + ['fixable', fixable], + ['hasSuggestions', hasSuggestions], + ['category', category], + ['recommended', recommended], + [ + 'requiresTypeChecking', + // eslint-disable-next-line no-restricted-syntax + 'requiresTypeChecking' in docs + ? // eslint-disable-next-line unicorn/consistent-destructuring, @typescript-eslint/no-deprecated + Boolean(docs.requiresTypeChecking) + : undefined, + ], + ]; + + const keyValuesStr: DeepReadonly<[string, string][]> = keyValue + .filter(([_key, value]) => value != null) + .map(([key, value]) => [ + key, + removeMultiLineCommentCharacter(toStr(value ?? '')), + ]); + + const tableHeader = ['key', 'value'] as const; + const [longestKeyLength, longestValueLength] = keyValuesStr.reduce< + readonly [SafeUint, SafeUint] + >( + ([keyMax, valueMax], [key, value]) => [ + toSafeUint(Math.max(keyMax, key.length)), + toSafeUint(Math.max(valueMax, value.length)), + ], + [toSafeUint(tableHeader[0].length), toSafeUint(tableHeader[1].length)], + ); + + const result = [ + '/**', + description == null + ? undefined + : ` * @description ${removeMultiLineCommentCharacter(description)}`, + url == null ? undefined : ` * @link ${url}`, + ' *', + ' * ```md', + ` * | ${tableHeader[0].padEnd( + longestKeyLength, + ' ', + )} | ${tableHeader[1].padEnd(longestValueLength, ' ')} |`, + ` * | ${':'.padEnd(longestKeyLength, '-')} | ${':'.padEnd( + longestValueLength, + '-', + )} |`, + ...keyValuesStr.map( + ([key, value]) => + ` * | ${key.padEnd(longestKeyLength, ' ')} | ${value.padEnd( + longestValueLength, + ' ', + )} |`, + ), + ' * ```', + ' */', + ]; + return result.filter((line) => line !== undefined).join('\n'); +}; + +const rawSchemaToString = ( + rawSchema: DeepReadonly, +): readonly string[] => + rawSchema === undefined + ? [] + : [ + ' /**', + ' * ### schema', + ' *', + ' * ```json', + + JSON.stringify(rawSchema, null, 2) + .split('\n') + .map((line) => ` * ${line}`) + .join('\n'), + ' * ```', + ' */', + ]; + +const createResult = async ( + schemaList: DeepReadonly< + { + ruleName: string; + docs: string; + deprecated: boolean; + schema: JSONSchema4[]; + rawSchema: JSONSchema4 | JSONSchema4[] | undefined; + }[] + >, + typeName: string, + ruleNamePrefix: string, +): Promise => { + const mut_resultToWrite: string[] = [ + '/* cSpell:disable */', + "import { type Linter } from 'eslint';", + "import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs';", + ...(schemaList.some(({ schema }) => schema.length === 1) + ? [ + '', + `type SpreadOptionsIfIsArray =`, + `T[1] extends readonly unknown[] ? readonly [${RuleSeverity}, ...T[1]] : T;`, + ] + : []), + '', + ]; + + for (const { ruleName, docs, deprecated, schema, rawSchema } of schemaList) { + mut_resultToWrite.push(docs, `namespace ${toCapitalCase(ruleName)} {`); + + if (deprecated) { + if (schema.length > 0) { + mut_resultToWrite.push(...rawSchemaToString(rawSchema)); + } + mut_resultToWrite.push(' export type RuleEntry = 0;'); + } else { + switch (schema.length) { + case 0: + mut_resultToWrite.push(` export type RuleEntry = ${RuleSeverity};`); + break; + + case 1: { + mut_resultToWrite.push(...rawSchemaToString(rawSchema)); + + const sc = schema[0]; + if (sc === undefined) { + throw new Error("schema can't be undefined here"); + } + + /* e.g. "export type Options = { ... };" */ + const optionsType = await compile( + // eslint-disable-next-line total-functions/no-unsafe-type-assertion + sc as JSONSchema4, + 'Options', + compilerConfig, + ).catch((error) => { + throw new Error(toStr(error)); + }); + + mut_resultToWrite.push( + optionsType, + '', + ' export type RuleEntry = ', + generatorOption.explicitRuleDefaultOption + ? `"off" | ${RuleSeverityWithDefaultOption}` + : 'Linter.StringSeverity', + ` | SpreadOptionsIfIsArray;`, + ); + break; + } + + default: { + mut_resultToWrite.push(...rawSchemaToString(rawSchema)); + + /* e.g. "export type Options = { ... };" */ + const optionsTypeList: readonly string[] = await Promise.all( + schema.map((s, index) => + compile( + // eslint-disable-next-line total-functions/no-unsafe-type-assertion + s as JSONSchema4, + `Options${index}`, + compilerConfig, + ), + ), + ).catch((error) => { + throw new Error(toStr(error)); + }); + + // e.g. "Options0, Options1, Options2" + const OptionsStrs: readonly `Options${number}`[] = + optionsTypeList.map((_, index) => `Options${index}` as const); + + mut_resultToWrite.push( + ...optionsTypeList, + '', + ' export type RuleEntry = ', + generatorOption.explicitRuleDefaultOption + ? `"off" | ${RuleSeverityWithDefaultOption}` + : 'Linter.RuleSeverity', + ...OptionsStrs.map( + (_, i) => + ` | readonly [${ + RuleSeverity + }, ${OptionsStrs.slice(0, toUint32(i + 1)).join(', ')}]`, + ), + ); + break; + } + } + } + mut_resultToWrite.push('}', '\n'); + } + + const deprecatedSchemaList = schemaList.filter((s) => s.deprecated); + + mut_resultToWrite.push( + `export type ${typeName} = Readonly<{`, + + ...schemaList + .filter((s) => !s.deprecated) + .map( + ({ ruleName }) => + `'${ruleNamePrefix}${ruleName}': ${toCapitalCase( + ruleName, + )}.RuleEntry;`, + ), + + ...(deprecatedSchemaList.length === 0 + ? [] + : [ + '', + ' // deprecated', + ...deprecatedSchemaList.map( + ({ ruleName }) => + `'${ruleNamePrefix}${ruleName}': ${toCapitalCase( + ruleName, + )}.RuleEntry;`, + ), + ]), + + '}>', + + '', + ); + + if (schemaList.some((s) => !s.deprecated && s.schema.length > 0)) { + mut_resultToWrite.push( + `export type ${typeName}Option = Readonly<{`, + + ...schemaList + .filter((s) => !s.deprecated && s.schema.length > 0) + .map(({ ruleName, schema }) => + [ + `'${ruleNamePrefix}${ruleName}': `, + schema.length === 1 + ? `${toCapitalCase(ruleName)}.Options;` + : `[${schema + .map( + (_, index) => `${toCapitalCase(ruleName)}.Options${index}`, + ) + .join(', ')}]`, + ].join(''), + ), + + '}>', + ); + } + + return mut_resultToWrite.join('\n'); +}; + +const createRulePrefix = ( + rulePrefixOrNull: string | undefined, + pluginName: string, +): string => + pluginName === 'eslint' + ? '' + : rulePrefixOrNull !== undefined && rulePrefixOrNull !== '' + ? rulePrefixOrNull + : `${pluginName.replace(/^eslint-plugin-/u, '')}/`; + +export const generateRulesTypeCore = async ( + typeName: string, + pluginName: string, + rulePrefixOrNull: string | undefined, +): Promise => { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, import/dynamic-import-chunkname + const pluginPackage = await import(pluginName); + + const rules: DeepReadonly<[string, Rule.RuleModule][]> = + pluginName === 'eslint' + ? // eslint-disable-next-line @typescript-eslint/no-deprecated + deepCopy(Array.from(builtinRules.entries())) + : Object.entries( + // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-member-access + pluginPackage.default.rules as Record, + ); + + const schemaList: DeepReadonly< + { + ruleName: string; + docs: string; + deprecated: boolean; + schema: JSONSchema4[]; + rawSchema: JSONSchema4 | JSONSchema4[]; + }[] + > = rules.map(([ruleName, { meta }]) => ({ + ruleName, + schema: normalizeToSchemaArray( + falseToUndefined( + pluginName === '@typescript-eslint/eslint-plugin' + ? // schema に入った変更で compile できなくなってしまったので暫定対応 + deepReplace(meta?.schema, '#/items/0/', '#/') + : meta?.schema, + ), + ), + deprecated: meta?.deprecated ?? false, + rawSchema: falseToUndefined(meta?.schema) ?? [], + docs: metaToString(meta), + })); + + return createResult( + schemaList, + typeName, + createRulePrefix(rulePrefixOrNull, pluginName), + ); +}; diff --git a/packages/eslint-configs/scripts/generate-rules-type-main.mts b/packages/eslint-configs/scripts/generate-rules-type-main.mts index 68b7f2a875..5b27bf2a62 100644 --- a/packages/eslint-configs/scripts/generate-rules-type-main.mts +++ b/packages/eslint-configs/scripts/generate-rules-type-main.mts @@ -1,167 +1,3 @@ -#!/usr/bin/env zx - -import { toThisDir } from '@noshiro/mono-utils'; -import 'zx/globals'; -import { eslintPlugins } from './eslint-plugins.mjs'; import { generateRulesType } from './generate-rules-type.mjs'; -import { replaceRulesType } from './replace.mjs'; - -const thisDir = toThisDir(import.meta.url); - -const outDir = path.resolve(thisDir, '../src/types/rules'); - -const prettierrcPath = path.resolve(thisDir, '../../../.prettierrc'); - -const eslintConfigPath = path.resolve(thisDir, './eslint.config.gen.mjs'); - -export const generateRulesTypeMain = async (): Promise => { - { - const result = await generate(); - - if (result.type === 'error') { - console.error(result.error); - return; - } - } - - { - console.log('running `lint --fix` ... (adding "readonly")'); - const result = await lintFix(); - - if (result.type === 'error') { - console.error(result.error); - return; - } - } - - { - console.log('formatting code ...'); - const result = await prettier(); - - if (result.type === 'error') { - console.error(result.error); - return; - } - } - - { - console.log('running `lint --fix` ... (sorting unions)'); - const result = await lintFix(); - - if (result.type === 'error') { - console.error(result.error); - return; - } - } - - { - console.log('formatting code ...'); - const result = await prettier(); - - if (result.type === 'error') { - console.error(result.error); - return; - } - } - - { - const result = await runReplace(); - - if (result.type === 'error') { - console.error(result.error); - return; - } - } - - { - console.log('formatting code ...'); - const result = await prettier(); - - if (result.type === 'error') { - console.error(result.error); - } - } -}; - -const generate = async (): Promise< - Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> -> => { - for (const plugin of Object.values(eslintPlugins)) { - console.log(`generating ${plugin.outputFileName} ...`); - - try { - const result = await generateRulesType( - plugin.typeName, - plugin.pluginName, - plugin.rulePrefix, - ); - - const targetFilePath = path.resolve(outDir, plugin.outputFileName); - - await fs.writeFile(targetFilePath, result); - } catch (error) { - return { type: 'error', error }; - } - } - - return { type: 'ok' }; -}; - -const lintFix = async (): Promise< - Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> -> => { - const targetFiles: readonly string[] = await glob(`${outDir}/*.mts`); - - const result = await $`ESLINT_USE_FLAT_CONFIG=true yarn eslint ${[ - '--no-ignore', - '--fix', - '--config', - eslintConfigPath, - ]} ${targetFiles}`; - - if (result.exitCode !== 0) { - return { type: 'error', error: result.stderr }; - } - - return { type: 'ok' }; -}; - -const prettier = async (): Promise< - Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> -> => { - const result = await $`yarn prettier ${[ - // '--cache --cache-strategy content', - `--config`, - prettierrcPath, - '--write', - outDir, - ]}`; - - if (result.exitCode !== 0) { - return { type: 'error', error: result.stderr }; - } - - return { type: 'ok' }; -}; - -const runReplace = async (): Promise< - Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> -> => { - for (const plugin of Object.values(eslintPlugins)) { - try { - console.log(`modifying ${plugin.outputFileName} ...`); - - const targetFilePath = `${outDir}/${plugin.outputFileName}`; - - const content = await fs.readFile(targetFilePath, { encoding: 'utf8' }); - - const result = replaceRulesType(content, plugin.typeName); - - await fs.writeFile(targetFilePath, result); - } catch (error) { - return { type: 'error', error }; - } - } - return { type: 'ok' }; -}; +await generateRulesType(); diff --git a/packages/eslint-configs/scripts/generate-rules-type.mts b/packages/eslint-configs/scripts/generate-rules-type.mts index 1e417f82a8..66b3f2d99d 100644 --- a/packages/eslint-configs/scripts/generate-rules-type.mts +++ b/packages/eslint-configs/scripts/generate-rules-type.mts @@ -1,368 +1,167 @@ -import { toSafeUint, toUint32 } from '@noshiro/mono-utils'; -import { type Rule } from 'eslint'; -import { builtinRules } from 'eslint/use-at-your-own-risk'; -import { type JSONSchema4 } from 'json-schema'; -import { compile, type Options } from 'json-schema-to-typescript'; -import { - deepCopy, - deepReplace, - falseToUndefined, - isArray, - toCapitalCase, - toStr, -} from './utils.mjs'; - -type Meta = DeepReadonly< - DeepPartial<{ - [K in keyof Rule.RuleMetaData]: K extends 'docs' - ? Required['docs'] & { category: string } - : Rule.RuleMetaData[K]; - }> ->; - -const generatorOption: Readonly<{ - explicitRuleDefaultOption: boolean; -}> = { - explicitRuleDefaultOption: true, -} as const; - -const RuleSeverityWithDefaultOption = 'RuleSeverityWithDefaultOption'; - -const RuleSeverity = generatorOption.explicitRuleDefaultOption - ? 'Linter.StringSeverity' - : 'Linter.RuleSeverity'; - -const compilerConfig = { - bannerComment: '', - format: false, - unknownAny: true, -} as const satisfies Partial; - -const normalizeToSchemaArray = ( - schema: DeepReadonly | undefined, -): DeepReadonly => - // schema が JSONSchema4 | JSONSchema4[] | undefined 型を満たしていない plugin があったためその問題を吸収する対応。 - typeof schema !== 'object' ? [] : isArray(schema) ? schema : [schema]; - -const removeMultiLineCommentCharacter = (str: string): string => - str.replace('/*', ' ').replace('*/', ' '); - -const metaToString = (meta: Meta | undefined): string => { - if (meta === undefined) return ''; - - const { deprecated, docs, fixable, hasSuggestions, type } = meta; - - if (docs === undefined) return ''; - - const { description, recommended, category, url } = docs; - - const keyValue: DeepReadonly<[string, boolean | string | undefined][]> = [ - ['type', type], - ['deprecated', deprecated], - ['fixable', fixable], - ['hasSuggestions', hasSuggestions], - ['category', category], - ['recommended', recommended], - [ - 'requiresTypeChecking', - // eslint-disable-next-line no-restricted-syntax - 'requiresTypeChecking' in docs - ? // eslint-disable-next-line unicorn/consistent-destructuring, @typescript-eslint/no-deprecated - Boolean(docs.requiresTypeChecking) - : undefined, - ], - ]; - - const keyValuesStr: DeepReadonly<[string, string][]> = keyValue - .filter(([_key, value]) => value != null) - .map(([key, value]) => [ - key, - removeMultiLineCommentCharacter(toStr(value ?? '')), - ]); - - const tableHeader = ['key', 'value'] as const; - const [longestKeyLength, longestValueLength] = keyValuesStr.reduce< - readonly [SafeUint, SafeUint] - >( - ([keyMax, valueMax], [key, value]) => [ - toSafeUint(Math.max(keyMax, key.length)), - toSafeUint(Math.max(valueMax, value.length)), - ], - [toSafeUint(tableHeader[0].length), toSafeUint(tableHeader[1].length)], - ); - - const result = [ - '/**', - description == null - ? undefined - : ` * @description ${removeMultiLineCommentCharacter(description)}`, - url == null ? undefined : ` * @link ${url}`, - ' *', - ' * ```md', - ` * | ${tableHeader[0].padEnd( - longestKeyLength, - ' ', - )} | ${tableHeader[1].padEnd(longestValueLength, ' ')} |`, - ` * | ${':'.padEnd(longestKeyLength, '-')} | ${':'.padEnd( - longestValueLength, - '-', - )} |`, - ...keyValuesStr.map( - ([key, value]) => - ` * | ${key.padEnd(longestKeyLength, ' ')} | ${value.padEnd( - longestValueLength, - ' ', - )} |`, - ), - ' * ```', - ' */', - ]; - return result.filter((line) => line !== undefined).join('\n'); +#!/usr/bin/env zx + +import { toThisDir } from '@noshiro/mono-utils'; +import 'zx/globals'; +import { eslintPlugins } from './eslint-plugins.mjs'; +import { generateRulesTypeCore } from './generate-rules-type-core.mjs'; +import { replaceRulesType } from './replace.mjs'; + +const thisDir = toThisDir(import.meta.url); + +const outDir = path.resolve(thisDir, '../src/types/rules'); + +const prettierrcPath = path.resolve(thisDir, '../../../.prettierrc'); + +const eslintConfigPath = path.resolve(thisDir, './eslint.config.gen.mjs'); + +export const generateRulesType = async (): Promise => { + { + const result = await generate(); + + if (result.type === 'error') { + console.error(result.error); + return; + } + } + + { + console.log('running `lint --fix` ... (adding "readonly")'); + const result = await lintFix(); + + if (result.type === 'error') { + console.error(result.error); + return; + } + } + + { + console.log('formatting code ...'); + const result = await prettier(); + + if (result.type === 'error') { + console.error(result.error); + return; + } + } + + { + console.log('running `lint --fix` ... (sorting unions)'); + const result = await lintFix(); + + if (result.type === 'error') { + console.error(result.error); + return; + } + } + + { + console.log('formatting code ...'); + const result = await prettier(); + + if (result.type === 'error') { + console.error(result.error); + return; + } + } + + { + const result = await runReplace(); + + if (result.type === 'error') { + console.error(result.error); + return; + } + } + + { + console.log('formatting code ...'); + const result = await prettier(); + + if (result.type === 'error') { + console.error(result.error); + } + } }; -const rawSchemaToString = ( - rawSchema: DeepReadonly, -): readonly string[] => - rawSchema === undefined - ? [] - : [ - ' /**', - ' * ### schema', - ' *', - ' * ```json', - - JSON.stringify(rawSchema, null, 2) - .split('\n') - .map((line) => ` * ${line}`) - .join('\n'), - ' * ```', - ' */', - ]; - -const createResult = async ( - schemaList: DeepReadonly< - { - ruleName: string; - docs: string; - deprecated: boolean; - schema: JSONSchema4[]; - rawSchema: JSONSchema4 | JSONSchema4[] | undefined; - }[] - >, - typeName: string, - ruleNamePrefix: string, -): Promise => { - const mut_resultToWrite: string[] = [ - '/* cSpell:disable */', - "import { type Linter } from 'eslint';", - "import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs';", - ...(schemaList.some(({ schema }) => schema.length === 1) - ? [ - '', - `type SpreadOptionsIfIsArray =`, - `T[1] extends readonly unknown[] ? readonly [${RuleSeverity}, ...T[1]] : T;`, - ] - : []), - '', - ]; - - for (const { ruleName, docs, deprecated, schema, rawSchema } of schemaList) { - mut_resultToWrite.push(docs, `namespace ${toCapitalCase(ruleName)} {`); - - if (deprecated) { - if (schema.length > 0) { - mut_resultToWrite.push(...rawSchemaToString(rawSchema)); - } - mut_resultToWrite.push(' export type RuleEntry = 0;'); - } else { - switch (schema.length) { - case 0: - mut_resultToWrite.push(` export type RuleEntry = ${RuleSeverity};`); - break; - - case 1: { - mut_resultToWrite.push(...rawSchemaToString(rawSchema)); - - const sc = schema[0]; - if (sc === undefined) { - throw new Error("schema can't be undefined here"); - } - - /* e.g. "export type Options = { ... };" */ - const optionsType = await compile( - // eslint-disable-next-line total-functions/no-unsafe-type-assertion - sc as JSONSchema4, - 'Options', - compilerConfig, - ).catch((error) => { - throw new Error(toStr(error)); - }); - - mut_resultToWrite.push( - optionsType, - '', - ' export type RuleEntry = ', - generatorOption.explicitRuleDefaultOption - ? `"off" | ${RuleSeverityWithDefaultOption}` - : 'Linter.StringSeverity', - ` | SpreadOptionsIfIsArray;`, - ); - break; - } - - default: { - mut_resultToWrite.push(...rawSchemaToString(rawSchema)); - - /* e.g. "export type Options = { ... };" */ - const optionsTypeList: readonly string[] = await Promise.all( - schema.map((s, index) => - compile( - // eslint-disable-next-line total-functions/no-unsafe-type-assertion - s as JSONSchema4, - `Options${index}`, - compilerConfig, - ), - ), - ).catch((error) => { - throw new Error(toStr(error)); - }); - - // e.g. "Options0, Options1, Options2" - const OptionsStrs: readonly `Options${number}`[] = - optionsTypeList.map((_, index) => `Options${index}` as const); - - mut_resultToWrite.push( - ...optionsTypeList, - '', - ' export type RuleEntry = ', - generatorOption.explicitRuleDefaultOption - ? `"off" | ${RuleSeverityWithDefaultOption}` - : 'Linter.RuleSeverity', - ...OptionsStrs.map( - (_, i) => - ` | readonly [${ - RuleSeverity - }, ${OptionsStrs.slice(0, toUint32(i + 1)).join(', ')}]`, - ), - ); - break; - } - } +const generate = async (): Promise< + Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> +> => { + for (const plugin of Object.values(eslintPlugins)) { + console.log(`generating ${plugin.outputFileName} ...`); + + try { + const result = await generateRulesTypeCore( + plugin.typeName, + plugin.pluginName, + plugin.rulePrefix, + ); + + const targetFilePath = path.resolve(outDir, plugin.outputFileName); + + await fs.writeFile(targetFilePath, result); + } catch (error) { + return { type: 'error', error }; } - mut_resultToWrite.push('}', '\n'); } - const deprecatedSchemaList = schemaList.filter((s) => s.deprecated); - - mut_resultToWrite.push( - `export type ${typeName} = Readonly<{`, - - ...schemaList - .filter((s) => !s.deprecated) - .map( - ({ ruleName }) => - `'${ruleNamePrefix}${ruleName}': ${toCapitalCase( - ruleName, - )}.RuleEntry;`, - ), - - ...(deprecatedSchemaList.length === 0 - ? [] - : [ - '', - ' // deprecated', - ...deprecatedSchemaList.map( - ({ ruleName }) => - `'${ruleNamePrefix}${ruleName}': ${toCapitalCase( - ruleName, - )}.RuleEntry;`, - ), - ]), - - '}>', - - '', - ); - - if (schemaList.some((s) => !s.deprecated && s.schema.length > 0)) { - mut_resultToWrite.push( - `export type ${typeName}Option = Readonly<{`, - - ...schemaList - .filter((s) => !s.deprecated && s.schema.length > 0) - .map(({ ruleName, schema }) => - [ - `'${ruleNamePrefix}${ruleName}': `, - schema.length === 1 - ? `${toCapitalCase(ruleName)}.Options;` - : `[${schema - .map( - (_, index) => `${toCapitalCase(ruleName)}.Options${index}`, - ) - .join(', ')}]`, - ].join(''), - ), - - '}>', - ); + return { type: 'ok' }; +}; + +const lintFix = async (): Promise< + Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> +> => { + const targetFiles: readonly string[] = await glob(`${outDir}/*.mts`); + + const result = await $`ESLINT_USE_FLAT_CONFIG=true yarn eslint ${[ + '--no-ignore', + '--fix', + '--config', + eslintConfigPath, + ]} ${targetFiles}`; + + if (result.exitCode !== 0) { + return { type: 'error', error: result.stderr }; + } + + return { type: 'ok' }; +}; + +const prettier = async (): Promise< + Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> +> => { + const result = await $`yarn prettier ${[ + // '--cache --cache-strategy content', + `--config`, + prettierrcPath, + '--write', + outDir, + ]}`; + + if (result.exitCode !== 0) { + return { type: 'error', error: result.stderr }; } - return mut_resultToWrite.join('\n'); + return { type: 'ok' }; }; -const createRulePrefix = ( - rulePrefixOrNull: string | undefined, - pluginName: string, -): string => - pluginName === 'eslint' - ? '' - : rulePrefixOrNull !== undefined && rulePrefixOrNull !== '' - ? rulePrefixOrNull - : `${pluginName.replace(/^eslint-plugin-/u, '')}/`; - -export const generateRulesType = async ( - typeName: string, - pluginName: string, - rulePrefixOrNull: string | undefined, -): Promise => { - // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, import/dynamic-import-chunkname - const pluginPackage = await import(pluginName); - - const rules: DeepReadonly<[string, Rule.RuleModule][]> = - pluginName === 'eslint' - ? // eslint-disable-next-line @typescript-eslint/no-deprecated - deepCopy(Array.from(builtinRules.entries())) - : Object.entries( - // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-member-access - pluginPackage.default.rules as Record, - ); - - const schemaList: DeepReadonly< - { - ruleName: string; - docs: string; - deprecated: boolean; - schema: JSONSchema4[]; - rawSchema: JSONSchema4 | JSONSchema4[]; - }[] - > = rules.map(([ruleName, { meta }]) => ({ - ruleName, - schema: normalizeToSchemaArray( - falseToUndefined( - pluginName === '@typescript-eslint/eslint-plugin' - ? // schema に入った変更で compile できなくなってしまったので暫定対応 - deepReplace(meta?.schema, '#/items/0/', '#/') - : meta?.schema, - ), - ), - deprecated: meta?.deprecated ?? false, - rawSchema: falseToUndefined(meta?.schema) ?? [], - docs: metaToString(meta), - })); - - return createResult( - schemaList, - typeName, - createRulePrefix(rulePrefixOrNull, pluginName), - ); +const runReplace = async (): Promise< + Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> +> => { + for (const plugin of Object.values(eslintPlugins)) { + try { + console.log(`modifying ${plugin.outputFileName} ...`); + + const targetFilePath = `${outDir}/${plugin.outputFileName}`; + + const content = await fs.readFile(targetFilePath, { encoding: 'utf8' }); + + const result = replaceRulesType(content, plugin.typeName); + + await fs.writeFile(targetFilePath, result); + } catch (error) { + return { type: 'error', error }; + } + } + + return { type: 'ok' }; }; diff --git a/packages/eslint-configs/scripts/update-dependencies.mts b/packages/eslint-configs/scripts/update-dependencies.mts index 56ea20048e..bb3c796287 100644 --- a/packages/eslint-configs/scripts/update-dependencies.mts +++ b/packages/eslint-configs/scripts/update-dependencies.mts @@ -1,7 +1,7 @@ /* eslint-disable @typescript-eslint/no-unused-expressions */ import { castMutable, isRecord, toThisDir } from '@noshiro/mono-utils'; import 'zx/globals'; -import { generateRulesTypeMain } from './generate-rules-type-main.mjs'; +import { generateRulesType } from './generate-rules-type.mjs'; const thisDir = toThisDir(import.meta.url); const monoRootDir = path.resolve(thisDir, '../../..'); @@ -90,7 +90,7 @@ const main = async (): Promise => { cd(eslintDir); echo`${eslintDir}: generating rules type`; - await generateRulesTypeMain(); + await generateRulesType(); cd(strictTsLibSourceDir); { From 11cd781dc20f503573ca8c2dc620cd70ae7f5850 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sat, 22 Feb 2025 17:19:51 +0900 Subject: [PATCH 20/25] fix: [eslint-configs] support DeprecatedInfo --- packages/eslint-configs/package.json | 2 +- .../scripts/generate-rules-type-core.mts | 37 +- .../types/rules/eslint-array-func-rules.mts | 6 + .../src/types/rules/eslint-cypress-rules.mts | 10 + .../types/rules/eslint-functional-rules.mts | 19 + .../src/types/rules/eslint-import-rules.mts | 382 ++++++++++-------- .../src/types/rules/eslint-jest-rules.mts | 380 +++++++++-------- .../src/types/rules/eslint-jsx-a11y-rules.mts | 180 +++++---- .../types/rules/eslint-playwright-rules.mts | 49 +++ .../src/types/rules/eslint-plugin-rules.mts | 31 ++ .../eslint-prefer-arrow-functions-rules.mts | 9 +- .../src/types/rules/eslint-promise-rules.mts | 123 +++--- .../types/rules/eslint-react-hooks-rules.mts | 2 + .../src/types/rules/eslint-react-rules.mts | 113 +++++- .../src/types/rules/eslint-rules.mts | 197 +++++++++ .../src/types/rules/eslint-security-rules.mts | 14 + .../rules/eslint-testing-library-rules.mts | 197 +++++---- .../rules/eslint-total-functions-rules.mts | 12 + .../rules/eslint-tree-shakable-rules.mts | 1 + .../src/types/rules/eslint-unicorn-rules.mts | 123 ++++++ .../src/types/rules/eslint-vitest-rules.mts | 51 +++ .../types/rules/typescript-eslint-rules.mts | 250 +++++++++--- packages/strict-ts-lib/source/package.json | 2 +- yarn.lock | 27 +- 24 files changed, 1573 insertions(+), 644 deletions(-) diff --git a/packages/eslint-configs/package.json b/packages/eslint-configs/package.json index 066e50f367..f6edda9afe 100644 --- a/packages/eslint-configs/package.json +++ b/packages/eslint-configs/package.json @@ -57,7 +57,7 @@ "@typescript-eslint/parser": "8.21.0", "@typescript-eslint/type-utils": "8.21.0", "@typescript-eslint/utils": "8.21.0", - "eslint": "9.18.0", + "eslint": "9.20.1", "eslint-import-resolver-typescript": "3.7.0", "eslint-plugin-array-func": "5.0.2", "eslint-plugin-cypress": "4.1.0", diff --git a/packages/eslint-configs/scripts/generate-rules-type-core.mts b/packages/eslint-configs/scripts/generate-rules-type-core.mts index 4eea4c6d51..24ba19b688 100644 --- a/packages/eslint-configs/scripts/generate-rules-type-core.mts +++ b/packages/eslint-configs/scripts/generate-rules-type-core.mts @@ -1,3 +1,4 @@ +import { type DeprecatedInfo } from '@eslint/core'; import { toSafeUint, toUint32 } from '@noshiro/mono-utils'; import { type Rule } from 'eslint'; import { builtinRules } from 'eslint/use-at-your-own-risk'; @@ -12,13 +13,11 @@ import { toStr, } from './utils.mjs'; -type Meta = DeepReadonly< - DeepPartial<{ - [K in keyof Rule.RuleMetaData]: K extends 'docs' - ? Required['docs'] & { category: string } - : Rule.RuleMetaData[K]; - }> ->; +const isDeprecated = ( + deprecated: boolean | DeepReadonly | undefined, +): boolean => + typeof deprecated === 'object' || + (typeof deprecated === 'boolean' && deprecated); const generatorOption: Readonly<{ explicitRuleDefaultOption: boolean; @@ -47,7 +46,7 @@ const normalizeToSchemaArray = ( const removeMultiLineCommentCharacter = (str: string): string => str.replace('/*', ' ').replace('*/', ' '); -const metaToString = (meta: Meta | undefined): string => { +const metaToString = (meta: DeepReadonly): string => { if (meta === undefined) return ''; const { deprecated, docs, fixable, hasSuggestions, type } = meta; @@ -58,7 +57,7 @@ const metaToString = (meta: Meta | undefined): string => { const keyValue: DeepReadonly<[string, boolean | string | undefined][]> = [ ['type', type], - ['deprecated', deprecated], + ['deprecated', isDeprecated(deprecated)], ['fixable', fixable], ['hasSuggestions', hasSuggestions], ['category', category], @@ -144,9 +143,9 @@ const createResult = async ( { ruleName: string; docs: string; - deprecated: boolean; + deprecated: boolean | DeprecatedInfo; schema: JSONSchema4[]; - rawSchema: JSONSchema4 | JSONSchema4[] | undefined; + rawSchema: JSONSchema4 | JSONSchema4[]; }[] >, typeName: string, @@ -169,7 +168,7 @@ const createResult = async ( for (const { ruleName, docs, deprecated, schema, rawSchema } of schemaList) { mut_resultToWrite.push(docs, `namespace ${toCapitalCase(ruleName)} {`); - if (deprecated) { + if (isDeprecated(deprecated)) { if (schema.length > 0) { mut_resultToWrite.push(...rawSchemaToString(rawSchema)); } @@ -252,13 +251,15 @@ const createResult = async ( mut_resultToWrite.push('}', '\n'); } - const deprecatedSchemaList = schemaList.filter((s) => s.deprecated); + const deprecatedSchemaList = schemaList.filter((s) => + isDeprecated(s.deprecated), + ); mut_resultToWrite.push( `export type ${typeName} = Readonly<{`, ...schemaList - .filter((s) => !s.deprecated) + .filter((s) => !isDeprecated(s.deprecated)) .map( ({ ruleName }) => `'${ruleNamePrefix}${ruleName}': ${toCapitalCase( @@ -284,12 +285,14 @@ const createResult = async ( '', ); - if (schemaList.some((s) => !s.deprecated && s.schema.length > 0)) { + if ( + schemaList.some((s) => !isDeprecated(s.deprecated) && s.schema.length > 0) + ) { mut_resultToWrite.push( `export type ${typeName}Option = Readonly<{`, ...schemaList - .filter((s) => !s.deprecated && s.schema.length > 0) + .filter((s) => !isDeprecated(s.deprecated) && s.schema.length > 0) .map(({ ruleName, schema }) => [ `'${ruleNamePrefix}${ruleName}': `, @@ -341,7 +344,7 @@ export const generateRulesTypeCore = async ( { ruleName: string; docs: string; - deprecated: boolean; + deprecated: boolean | DeprecatedInfo; schema: JSONSchema4[]; rawSchema: JSONSchema4 | JSONSchema4[]; }[] diff --git a/packages/eslint-configs/src/types/rules/eslint-array-func-rules.mts b/packages/eslint-configs/src/types/rules/eslint-array-func-rules.mts index ed18f1123c..80953e3cfc 100644 --- a/packages/eslint-configs/src/types/rules/eslint-array-func-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-array-func-rules.mts @@ -8,6 +8,7 @@ import { type Linter } from 'eslint'; * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -24,6 +25,7 @@ namespace FromMap { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -40,6 +42,7 @@ namespace NoUnnecessaryThisArg { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -55,6 +58,7 @@ namespace PreferArrayFrom { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -70,6 +74,7 @@ namespace AvoidReverse { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -85,6 +90,7 @@ namespace PreferFlatMap { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` diff --git a/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts b/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts index 96adb69684..5deb064804 100644 --- a/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -34,6 +35,7 @@ namespace NoAssigningReturnValues { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -81,6 +83,7 @@ namespace UnsafeToChainCommand { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -98,6 +101,7 @@ namespace NoUnnecessaryWaiting { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -115,6 +119,7 @@ namespace NoAsyncBefore { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -132,6 +137,7 @@ namespace NoAsyncTests { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -149,6 +155,7 @@ namespace AssertionBeforeScreenshot { * | key | value | * | :---------- | :-------------- | * | type | suggestion | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -166,6 +173,7 @@ namespace RequireDataSelectors { * | key | value | * | :---------- | :-------------- | * | type | suggestion | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -183,6 +191,7 @@ namespace NoForce { * | key | value | * | :---------- | :-------------- | * | type | suggestion | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -200,6 +209,7 @@ namespace NoPause { * | key | value | * | :---------- | :-------------- | * | type | suggestion | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` diff --git a/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts b/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts index 7ee2d514df..03cf14877d 100644 --- a/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | category | Currying | * | recommended | recommended | * | requiresTypeChecking | true | @@ -696,6 +697,7 @@ namespace FunctionalParameters { * | key | value | * | :------------------- | :----------- | * | type | suggestion | + * | deprecated | false | * | category | No Mutations | * | recommended | recommended | * | requiresTypeChecking | true | @@ -1339,6 +1341,7 @@ namespace ImmutableData { * | key | value | * | :------------------- | :----------------- | * | type | suggestion | + * | deprecated | false | * | category | No Other Paradigms | * | recommended | recommended | * | requiresTypeChecking | false | @@ -1397,6 +1400,7 @@ namespace NoClasses { * | key | value | * | :------------------- | :----------------- | * | type | suggestion | + * | deprecated | false | * | category | No Other Paradigms | * | recommended | recommended | * | requiresTypeChecking | false | @@ -1455,6 +1459,7 @@ namespace NoClassInheritance { * | key | value | * | :------------------- | :------------ | * | type | suggestion | + * | deprecated | false | * | category | No Statements | * | recommended | recommended | * | requiresTypeChecking | true | @@ -1507,6 +1512,7 @@ namespace NoConditionalStatements { * | key | value | * | :------------------- | :------------ | * | type | suggestion | + * | deprecated | false | * | category | No Statements | * | recommended | recommended | * | requiresTypeChecking | true | @@ -1563,6 +1569,7 @@ namespace NoExpressionStatements { * | key | value | * | :------------------- | :----------- | * | type | suggestion | + * | deprecated | false | * | category | No Mutations | * | recommended | recommended | * | requiresTypeChecking | false | @@ -1619,6 +1626,7 @@ namespace NoLet { * | key | value | * | :------------------- | :------------ | * | type | suggestion | + * | deprecated | false | * | category | No Statements | * | recommended | recommended | * | requiresTypeChecking | false | @@ -1637,6 +1645,7 @@ namespace NoLoopStatements { * | key | value | * | :------------------- | :----------------- | * | type | suggestion | + * | deprecated | false | * | category | No Other Paradigms | * | recommended | recommended | * | requiresTypeChecking | true | @@ -1683,6 +1692,7 @@ namespace NoMixedTypes { * | key | value | * | :------------------- | :------------ | * | type | suggestion | + * | deprecated | false | * | category | No Exceptions | * | recommended | false | * | requiresTypeChecking | false | @@ -1701,6 +1711,7 @@ namespace NoPromiseReject { * | key | value | * | :------------------- | :------------ | * | type | suggestion | + * | deprecated | false | * | category | No Statements | * | recommended | recommended | * | requiresTypeChecking | true | @@ -1751,6 +1762,7 @@ namespace NoReturnVoid { * | key | value | * | :------------------- | :----------------- | * | type | suggestion | + * | deprecated | false | * | category | No Other Paradigms | * | recommended | recommended | * | requiresTypeChecking | false | @@ -1769,6 +1781,7 @@ namespace NoThisExpressions { * | key | value | * | :------------------- | :------------ | * | type | suggestion | + * | deprecated | false | * | category | No Exceptions | * | recommended | recommended | * | requiresTypeChecking | false | @@ -1811,6 +1824,7 @@ namespace NoThrowStatements { * | key | value | * | :------------------- | :------------ | * | type | suggestion | + * | deprecated | false | * | category | No Exceptions | * | recommended | recommended | * | requiresTypeChecking | false | @@ -1857,6 +1871,7 @@ namespace NoTryStatements { * | key | value | * | :------------------- | :----------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | category | No Mutations | @@ -3642,6 +3657,7 @@ namespace PreferImmutableTypes { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | category | Stylistic | * | recommended | recommended | * | requiresTypeChecking | true | @@ -3756,6 +3772,7 @@ namespace PreferReadonlyType { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Stylistic | * | recommended | recommended | @@ -3799,6 +3816,7 @@ namespace PreferTacit { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Stylistic | * | recommended | recommended | @@ -3838,6 +3856,7 @@ namespace ReadonlyType { * | key | value | * | :------------------- | :----------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | category | No Mutations | diff --git a/packages/eslint-configs/src/types/rules/eslint-import-rules.mts b/packages/eslint-configs/src/types/rules/eslint-import-rules.mts index 8103e5e0e3..d6119f0636 100644 --- a/packages/eslint-configs/src/types/rules/eslint-import-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-import-rules.mts @@ -14,10 +14,11 @@ type SpreadOptionsIfIsArray< * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-unresolved.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | problem | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | problem | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace NoUnresolved { @@ -82,10 +83,11 @@ namespace NoUnresolved { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/named.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | problem | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | problem | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace Named { @@ -122,10 +124,11 @@ namespace Named { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/default.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | problem | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | problem | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace Default { @@ -139,10 +142,11 @@ namespace Default { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/namespace.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | problem | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | problem | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace Namespace { @@ -185,11 +189,12 @@ namespace Namespace { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-namespace.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | category | Style guide | * ``` */ namespace NoNamespace { @@ -230,10 +235,11 @@ namespace NoNamespace { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/export.md * * ```md - * | key | value | - * | :------- | :--------------- | - * | type | problem | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------------- | + * | type | problem | + * | deprecated | false | + * | category | Helpful warnings | * ``` */ namespace Export { @@ -246,10 +252,11 @@ namespace Export { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-mutable-exports.md * * ```md - * | key | value | - * | :------- | :--------------- | - * | type | suggestion | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Helpful warnings | * ``` */ namespace NoMutableExports { @@ -262,10 +269,11 @@ namespace NoMutableExports { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/extensions.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace Extensions { @@ -416,10 +424,11 @@ namespace Extensions { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-restricted-paths.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | problem | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | problem | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace NoRestrictedPaths { @@ -521,10 +530,11 @@ namespace NoRestrictedPaths { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-internal-modules.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | suggestion | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace NoInternalModules { @@ -584,10 +594,11 @@ namespace NoInternalModules { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/group-exports.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace GroupExports { @@ -600,11 +611,12 @@ namespace GroupExports { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-relative-packages.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | suggestion | - * | fixable | code | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | category | Static analysis | * ``` */ namespace NoRelativePackages { @@ -659,10 +671,11 @@ namespace NoRelativePackages { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-relative-parent-imports.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | suggestion | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace NoRelativeParentImports { @@ -717,11 +730,12 @@ namespace NoRelativeParentImports { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/consistent-type-specifier-style.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | category | Style guide | * ``` */ namespace ConsistentTypeSpecifierStyle { @@ -758,6 +772,7 @@ namespace ConsistentTypeSpecifierStyle { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Static analysis | * | recommended | true | * ``` @@ -773,10 +788,11 @@ namespace NoSelfImport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-cycle.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | suggestion | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace NoCycle { @@ -875,10 +891,11 @@ namespace NoCycle { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-named-default.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace NoNamedDefault { @@ -891,10 +908,11 @@ namespace NoNamedDefault { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-named-as-default.md * * ```md - * | key | value | - * | :------- | :--------------- | - * | type | problem | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------------- | + * | type | problem | + * | deprecated | false | + * | category | Helpful warnings | * ``` */ namespace NoNamedAsDefault { @@ -907,10 +925,11 @@ namespace NoNamedAsDefault { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-named-as-default-member.md * * ```md - * | key | value | - * | :------- | :--------------- | - * | type | suggestion | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Helpful warnings | * ``` */ namespace NoNamedAsDefaultMember { @@ -923,10 +942,11 @@ namespace NoNamedAsDefaultMember { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-anonymous-default-export.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace NoAnonymousDefaultExport { @@ -1008,10 +1028,11 @@ namespace NoAnonymousDefaultExport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-unused-modules.md * * ```md - * | key | value | - * | :------- | :--------------- | - * | type | suggestion | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Helpful warnings | * ``` */ namespace NoUnusedModules { @@ -1125,10 +1146,11 @@ namespace NoUnusedModules { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-commonjs.md * * ```md - * | key | value | - * | :------- | :------------- | - * | type | suggestion | - * | category | Module systems | + * | key | value | + * | :--------- | :------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Module systems | * ``` */ namespace NoCommonjs { @@ -1195,10 +1217,11 @@ namespace NoCommonjs { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-amd.md * * ```md - * | key | value | - * | :------- | :------------- | - * | type | suggestion | - * | category | Module systems | + * | key | value | + * | :--------- | :------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Module systems | * ``` */ namespace NoAmd { @@ -1211,11 +1234,12 @@ namespace NoAmd { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-duplicates.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | problem | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | problem | + * | deprecated | false | + * | fixable | code | + * | category | Style guide | * ``` */ namespace NoDuplicates { @@ -1256,11 +1280,12 @@ namespace NoDuplicates { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/first.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | category | Style guide | * ``` */ namespace First { @@ -1293,10 +1318,11 @@ namespace First { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/max-dependencies.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace MaxDependencies { @@ -1337,10 +1363,11 @@ namespace MaxDependencies { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-extraneous-dependencies.md * * ```md - * | key | value | - * | :------- | :--------------- | - * | type | problem | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------------- | + * | type | problem | + * | deprecated | false | + * | category | Helpful warnings | * ``` */ namespace NoExtraneousDependencies { @@ -1420,11 +1447,12 @@ namespace NoExtraneousDependencies { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-absolute-path.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | suggestion | - * | fixable | code | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | category | Static analysis | * ``` */ namespace NoAbsolutePath { @@ -1479,10 +1507,11 @@ namespace NoAbsolutePath { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-nodejs-modules.md * * ```md - * | key | value | - * | :------- | :------------- | - * | type | suggestion | - * | category | Module systems | + * | key | value | + * | :--------- | :------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Module systems | * ``` */ namespace NoNodejsModules { @@ -1523,10 +1552,11 @@ namespace NoNodejsModules { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-webpack-loader-syntax.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | problem | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | problem | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace NoWebpackLoaderSyntax { @@ -1539,11 +1569,12 @@ namespace NoWebpackLoaderSyntax { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/order.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | category | Style guide | * ``` */ namespace Order { @@ -1740,11 +1771,12 @@ namespace Order { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/newline-after-import.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | layout | - * | fixable | whitespace | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | layout | + * | deprecated | false | + * | fixable | whitespace | + * | category | Style guide | * ``` */ namespace NewlineAfterImport { @@ -1790,10 +1822,11 @@ namespace NewlineAfterImport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/prefer-default-export.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace PreferDefaultExport { @@ -1835,10 +1868,11 @@ namespace PreferDefaultExport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-default-export.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace NoDefaultExport { @@ -1851,10 +1885,11 @@ namespace NoDefaultExport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-named-export.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace NoNamedExport { @@ -1867,10 +1902,11 @@ namespace NoNamedExport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-dynamic-require.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | suggestion | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Static analysis | * ``` */ namespace NoDynamicRequire { @@ -1907,10 +1943,11 @@ namespace NoDynamicRequire { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/unambiguous.md * * ```md - * | key | value | - * | :------- | :------------- | - * | type | suggestion | - * | category | Module systems | + * | key | value | + * | :--------- | :------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Module systems | * ``` */ namespace Unambiguous { @@ -1923,10 +1960,11 @@ namespace Unambiguous { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-unassigned-import.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace NoUnassignedImport { @@ -1987,11 +2025,12 @@ namespace NoUnassignedImport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-useless-path-segments.md * * ```md - * | key | value | - * | :------- | :-------------- | - * | type | suggestion | - * | fixable | code | - * | category | Static analysis | + * | key | value | + * | :--------- | :-------------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | category | Static analysis | * ``` */ namespace NoUselessPathSegments { @@ -2035,6 +2074,7 @@ namespace NoUselessPathSegments { * | key | value | * | :------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Style guide | * ``` @@ -2086,6 +2126,7 @@ namespace DynamicImportChunkname { * | key | value | * | :---------- | :------------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | category | Module systems | * | recommended | true | @@ -2128,6 +2169,7 @@ namespace NoImportModuleExports { * | key | value | * | :------------- | :--------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | category | Helpful warnings | @@ -2143,10 +2185,11 @@ namespace NoEmptyNamedBlocks { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/exports-last.md * * ```md - * | key | value | - * | :------- | :---------- | - * | type | suggestion | - * | category | Style guide | + * | key | value | + * | :--------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | category | Style guide | * ``` */ namespace ExportsLast { @@ -2159,10 +2202,11 @@ namespace ExportsLast { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-deprecated.md * * ```md - * | key | value | - * | :------- | :--------------- | - * | type | suggestion | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------------- | + * | type | suggestion | + * | deprecated | false | + * | category | Helpful warnings | * ``` */ namespace NoDeprecated { diff --git a/packages/eslint-configs/src/types/rules/eslint-jest-rules.mts b/packages/eslint-configs/src/types/rules/eslint-jest-rules.mts index 4deb7c2bf6..7a06432c13 100644 --- a/packages/eslint-configs/src/types/rules/eslint-jest-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-jest-rules.mts @@ -14,10 +14,11 @@ type SpreadOptionsIfIsArray< * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/consistent-test-it.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace ConsistentTestIt { @@ -66,9 +67,10 @@ namespace ConsistentTestIt { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/expect-expect.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace ExpectExpect { @@ -115,9 +117,10 @@ namespace ExpectExpect { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/max-expects.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace MaxExpects { @@ -155,9 +158,10 @@ namespace MaxExpects { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/max-nested-describe.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace MaxNestedDescribe { @@ -195,10 +199,11 @@ namespace MaxNestedDescribe { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-alias-methods.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoAliasMethods { @@ -211,9 +216,10 @@ namespace NoAliasMethods { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-commented-out-tests.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoCommentedOutTests { @@ -226,9 +232,10 @@ namespace NoCommentedOutTests { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-conditional-expect.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoConditionalExpect { @@ -241,9 +248,10 @@ namespace NoConditionalExpect { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-conditional-in-test.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoConditionalInTest { @@ -256,9 +264,10 @@ namespace NoConditionalInTest { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-confusing-set-timeout.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoConfusingSetTimeout { @@ -271,10 +280,11 @@ namespace NoConfusingSetTimeout { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-deprecated-functions.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoDeprecatedFunctions { @@ -287,9 +297,10 @@ namespace NoDeprecatedFunctions { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-disabled-tests.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoDisabledTests { @@ -305,6 +316,7 @@ namespace NoDisabledTests { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * ``` */ @@ -318,9 +330,10 @@ namespace NoDoneCallback { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-duplicate-hooks.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoDuplicateHooks { @@ -333,9 +346,10 @@ namespace NoDuplicateHooks { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-export.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoExport { @@ -351,6 +365,7 @@ namespace NoExport { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * ``` */ @@ -364,9 +379,10 @@ namespace NoFocusedTests { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-hooks.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoHooks { @@ -409,9 +425,10 @@ namespace NoHooks { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-identical-title.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoIdenticalTitle { @@ -424,9 +441,10 @@ namespace NoIdenticalTitle { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-interpolation-in-snapshots.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoInterpolationInSnapshots { @@ -439,10 +457,11 @@ namespace NoInterpolationInSnapshots { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-jasmine-globals.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoJasmineGlobals { @@ -455,9 +474,10 @@ namespace NoJasmineGlobals { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-large-snapshots.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoLargeSnapshots { @@ -505,9 +525,10 @@ namespace NoLargeSnapshots { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-mocks-import.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoMocksImport { @@ -520,9 +541,10 @@ namespace NoMocksImport { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-restricted-jest-methods.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoRestrictedJestMethods { @@ -557,9 +579,10 @@ namespace NoRestrictedJestMethods { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-restricted-matchers.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoRestrictedMatchers { @@ -594,9 +617,10 @@ namespace NoRestrictedMatchers { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-standalone-expect.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoStandaloneExpect { @@ -636,10 +660,11 @@ namespace NoStandaloneExpect { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-test-prefixes.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoTestPrefixes { @@ -652,9 +677,10 @@ namespace NoTestPrefixes { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-test-return-statement.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoTestReturnStatement { @@ -667,10 +693,11 @@ namespace NoTestReturnStatement { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/no-untyped-mock-factory.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoUntypedMockFactory { @@ -819,9 +846,10 @@ namespace PaddingAroundTestBlocks { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-called-with.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferCalledWith { @@ -834,10 +862,11 @@ namespace PreferCalledWith { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-comparison-matcher.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferComparisonMatcher { @@ -850,9 +879,10 @@ namespace PreferComparisonMatcher { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-each.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferEach { @@ -868,6 +898,7 @@ namespace PreferEach { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * ``` */ @@ -884,6 +915,7 @@ namespace PreferEqualityMatcher { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * ``` */ @@ -929,10 +961,11 @@ namespace PreferExpectAssertions { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-expect-resolves.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferExpectResolves { @@ -945,9 +978,10 @@ namespace PreferExpectResolves { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-hooks-in-order.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferHooksInOrder { @@ -960,9 +994,10 @@ namespace PreferHooksInOrder { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-hooks-on-top.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferHooksOnTop { @@ -975,10 +1010,11 @@ namespace PreferHooksOnTop { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-importing-jest-globals.md * * ```md - * | key | value | - * | :------ | :------ | - * | type | problem | - * | fixable | code | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferImportingJestGlobals { @@ -1033,10 +1069,11 @@ namespace PreferImportingJestGlobals { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-jest-mocked.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferJestMocked { @@ -1049,10 +1086,11 @@ namespace PreferJestMocked { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-lowercase-title.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferLowercaseTitle { @@ -1111,10 +1149,11 @@ namespace PreferLowercaseTitle { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-mock-promise-shorthand.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferMockPromiseShorthand { @@ -1127,9 +1166,10 @@ namespace PreferMockPromiseShorthand { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-snapshot-hint.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferSnapshotHint { @@ -1162,10 +1202,11 @@ namespace PreferSnapshotHint { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-spy-on.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferSpyOn { @@ -1181,6 +1222,7 @@ namespace PreferSpyOn { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * ``` */ @@ -1194,10 +1236,11 @@ namespace PreferStrictEqual { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-to-be.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferToBe { @@ -1210,10 +1253,11 @@ namespace PreferToBe { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-to-contain.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferToContain { @@ -1226,10 +1270,11 @@ namespace PreferToContain { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-to-have-length.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferToHaveLength { @@ -1242,10 +1287,11 @@ namespace PreferToHaveLength { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/prefer-todo.md * * ```md - * | key | value | - * | :------ | :----- | - * | type | layout | - * | fixable | code | + * | key | value | + * | :--------- | :----- | + * | type | layout | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferTodo { @@ -1258,9 +1304,10 @@ namespace PreferTodo { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/require-hook.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace RequireHook { @@ -1300,9 +1347,10 @@ namespace RequireHook { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/require-to-throw-message.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace RequireToThrowMessage { @@ -1315,9 +1363,10 @@ namespace RequireToThrowMessage { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/require-top-level-describe.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace RequireTopLevelDescribe { @@ -1358,6 +1407,7 @@ namespace RequireTopLevelDescribe { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | requiresTypeChecking | true | * ``` */ @@ -1397,9 +1447,10 @@ namespace UnboundMethod { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/valid-describe-callback.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace ValidDescribeCallback { @@ -1412,9 +1463,10 @@ namespace ValidDescribeCallback { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/valid-expect-in-promise.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace ValidExpectInPromise { @@ -1427,10 +1479,11 @@ namespace ValidExpectInPromise { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/valid-expect.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace ValidExpect { @@ -1485,10 +1538,11 @@ namespace ValidExpect { * @link https://github.com/jest-community/eslint-plugin-jest/blob/v28.11.0/docs/rules/valid-title.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace ValidTitle { diff --git a/packages/eslint-configs/src/types/rules/eslint-jsx-a11y-rules.mts b/packages/eslint-configs/src/types/rules/eslint-jsx-a11y-rules.mts index f79392510e..e2954cf7c2 100644 --- a/packages/eslint-configs/src/types/rules/eslint-jsx-a11y-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-jsx-a11y-rules.mts @@ -42,8 +42,9 @@ namespace AccessibleEmoji { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/alt-text.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AltText { @@ -122,8 +123,9 @@ namespace AltText { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-ambiguous-text.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AnchorAmbiguousText { @@ -165,8 +167,9 @@ namespace AnchorAmbiguousText { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-has-content.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AnchorHasContent { @@ -208,8 +211,9 @@ namespace AnchorHasContent { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-is-valid.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AnchorIsValid { @@ -279,8 +283,9 @@ namespace AnchorIsValid { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-activedescendant-has-tabindex.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AriaActivedescendantHasTabindex { @@ -310,8 +315,9 @@ namespace AriaActivedescendantHasTabindex { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-props.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AriaProps { @@ -341,8 +347,9 @@ namespace AriaProps { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-proptypes.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AriaProptypes { @@ -373,8 +380,9 @@ namespace AriaProptypes { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-role.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AriaRole { @@ -421,8 +429,9 @@ namespace AriaRole { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-unsupported-elements.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AriaUnsupportedElements { @@ -452,8 +461,9 @@ namespace AriaUnsupportedElements { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/autocomplete-valid.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace AutocompleteValid { @@ -496,8 +506,9 @@ namespace AutocompleteValid { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/click-events-have-key-events.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace ClickEventsHaveKeyEvents { @@ -527,8 +538,9 @@ namespace ClickEventsHaveKeyEvents { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/control-has-associated-label.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace ControlHasAssociatedLabel { @@ -604,8 +616,9 @@ namespace ControlHasAssociatedLabel { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/heading-has-content.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace HeadingHasContent { @@ -647,8 +660,9 @@ namespace HeadingHasContent { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/html-has-lang.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace HtmlHasLang { @@ -678,8 +692,9 @@ namespace HtmlHasLang { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/iframe-has-title.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace IframeHasTitle { @@ -710,8 +725,9 @@ namespace IframeHasTitle { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/img-redundant-alt.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace ImgRedundantAlt { @@ -763,8 +779,9 @@ namespace ImgRedundantAlt { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/interactive-supports-focus.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace InteractiveSupportsFocus { @@ -879,8 +896,9 @@ namespace InteractiveSupportsFocus { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/label-has-associated-control.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace LabelHasAssociatedControl { @@ -1051,8 +1069,9 @@ namespace LabelHasFor { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/lang.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace Lang { @@ -1083,8 +1102,9 @@ namespace Lang { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/media-has-caption.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace MediaHasCaption { @@ -1145,8 +1165,9 @@ namespace MediaHasCaption { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/mouse-events-have-key-events.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace MouseEventsHaveKeyEvents { @@ -1202,8 +1223,9 @@ namespace MouseEventsHaveKeyEvents { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-access-key.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoAccessKey { @@ -1233,8 +1255,9 @@ namespace NoAccessKey { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-aria-hidden-on-focusable.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoAriaHiddenOnFocusable { @@ -1264,8 +1287,9 @@ namespace NoAriaHiddenOnFocusable { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-autofocus.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoAutofocus { @@ -1303,8 +1327,9 @@ namespace NoAutofocus { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-distracting-elements.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoDistractingElements { @@ -1352,8 +1377,9 @@ namespace NoDistractingElements { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-interactive-element-to-noninteractive-role.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoInteractiveElementToNoninteractiveRole { @@ -1390,8 +1416,9 @@ namespace NoInteractiveElementToNoninteractiveRole { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-noninteractive-element-interactions.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoNoninteractiveElementInteractions { @@ -1433,8 +1460,9 @@ namespace NoNoninteractiveElementInteractions { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-noninteractive-element-to-interactive-role.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoNoninteractiveElementToInteractiveRole { @@ -1470,8 +1498,9 @@ namespace NoNoninteractiveElementToInteractiveRole { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-noninteractive-tabindex.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoNoninteractiveTabindex { @@ -1554,8 +1583,9 @@ namespace NoOnchange { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-redundant-roles.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoRedundantRoles { @@ -1592,8 +1622,9 @@ namespace NoRedundantRoles { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-static-element-interactions.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace NoStaticElementInteractions { @@ -1635,8 +1666,9 @@ namespace NoStaticElementInteractions { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/prefer-tag-over-role.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace PreferTagOverRole { @@ -1667,8 +1699,9 @@ namespace PreferTagOverRole { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/role-has-required-aria-props.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace RoleHasRequiredAriaProps { @@ -1699,8 +1732,9 @@ namespace RoleHasRequiredAriaProps { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/role-supports-aria-props.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace RoleSupportsAriaProps { @@ -1730,8 +1764,9 @@ namespace RoleSupportsAriaProps { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/scope.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace Scope { @@ -1761,8 +1796,9 @@ namespace Scope { * @link https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/tabindex-no-positive.md * * ```md - * | key | value | - * | :-- | :---- | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace TabindexNoPositive { diff --git a/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts b/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts index 2fecd39001..3e7a8e9b34 100644 --- a/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :------------- | * | type | problem | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -63,6 +64,7 @@ namespace ExpectExpect { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -105,6 +107,7 @@ namespace MaxExpects { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -147,6 +150,7 @@ namespace MaxNestedDescribe { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | category | Possible Errors | * | recommended | true | @@ -192,6 +196,7 @@ namespace MissingPlaywrightAwait { * | key | value | * | :---------- | :------------- | * | type | problem | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -209,6 +214,7 @@ namespace NoCommentedOutTests { * | key | value | * | :---------- | :------------- | * | type | problem | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -226,6 +232,7 @@ namespace NoConditionalExpect { * | key | value | * | :---------- | :------------- | * | type | problem | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -243,6 +250,7 @@ namespace NoConditionalInTest { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -260,6 +268,7 @@ namespace NoDuplicateHooks { * | key | value | * | :------------- | :-------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Possible Errors | * | recommended | true | @@ -279,6 +288,7 @@ namespace NoElementHandle { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -296,6 +306,7 @@ namespace NoEval { * | key | value | * | :------------- | :-------------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | category | Possible Errors | * | recommended | true | @@ -314,6 +325,7 @@ namespace NoFocusedTest { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -331,6 +343,7 @@ namespace NoForceOption { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -348,6 +361,7 @@ namespace NoGetByTitle { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -395,6 +409,7 @@ namespace NoHooks { * | key | value | * | :---------- | :------------- | * | type | problem | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -412,6 +427,7 @@ namespace NoNestedStep { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -429,6 +445,7 @@ namespace NoNetworkidle { * | key | value | * | :---------- | :------------- | * | type | problem | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -446,6 +463,7 @@ namespace NoNthMethods { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -463,6 +481,7 @@ namespace NoPagePause { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -507,6 +526,7 @@ namespace NoRawLocators { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -546,6 +566,7 @@ namespace NoRestrictedMatchers { * | key | value | * | :------------- | :------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Best Practices | * | recommended | true | @@ -589,6 +610,7 @@ namespace NoSkippedTest { * | key | value | * | :------------- | :------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Best Practices | * | recommended | true | @@ -632,6 +654,7 @@ namespace NoSlowedTest { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -650,6 +673,7 @@ namespace NoStandaloneExpect { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | category | Possible Errors | * | recommended | true | @@ -668,6 +692,7 @@ namespace NoUnsafeReferences { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | category | Possible Errors | * | recommended | true | @@ -686,6 +711,7 @@ namespace NoUselessAwait { * | key | value | * | :---------- | :------------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | true | @@ -704,6 +730,7 @@ namespace NoUselessNot { * | key | value | * | :------------- | :------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Best Practices | * | recommended | true | @@ -722,6 +749,7 @@ namespace NoWaitForSelector { * | key | value | * | :------------- | :------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Best Practices | * | recommended | true | @@ -740,6 +768,7 @@ namespace NoWaitForTimeout { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -758,6 +787,7 @@ namespace PreferComparisonMatcher { * | key | value | * | :------------- | :------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Best Practices | * | recommended | false | @@ -776,6 +806,7 @@ namespace PreferEqualityMatcher { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -793,6 +824,7 @@ namespace PreferHooksInOrder { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -810,6 +842,7 @@ namespace PreferHooksOnTop { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -827,6 +860,7 @@ namespace PreferLocator { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -889,6 +923,7 @@ namespace PreferLowercaseTitle { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -932,6 +967,7 @@ namespace PreferNativeLocators { * | key | value | * | :------------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | category | Best Practices | @@ -951,6 +987,7 @@ namespace PreferStrictEqual { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -969,6 +1006,7 @@ namespace PreferToBe { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -987,6 +1025,7 @@ namespace PreferToContain { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -1005,6 +1044,7 @@ namespace PreferToHaveCount { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -1023,6 +1063,7 @@ namespace PreferToHaveLength { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | true | @@ -1041,6 +1082,7 @@ namespace PreferWebFirstAssertions { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -1085,6 +1127,7 @@ namespace RequireHook { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -1102,6 +1145,7 @@ namespace RequireSoftAssertions { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -1119,6 +1163,7 @@ namespace RequireToThrowMessage { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -1161,6 +1206,7 @@ namespace RequireTopLevelDescribe { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -1178,6 +1224,7 @@ namespace ValidDescribeCallback { * | key | value | * | :---------- | :-------------- | * | type | problem | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -1225,6 +1272,7 @@ namespace ValidExpect { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -1242,6 +1290,7 @@ namespace ValidExpectInPromise { * | key | value | * | :---------- | :------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | true | diff --git a/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts b/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts index 203d762791..1f93f3bfbc 100644 --- a/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | category | Tests | * | recommended | false | * ``` @@ -60,6 +61,7 @@ namespace ConsistentOutput { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | category | Rules | * | recommended | true | * ``` @@ -77,6 +79,7 @@ namespace FixerReturn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Rules | * | recommended | false | @@ -116,6 +119,7 @@ namespace MetaPropertyOrdering { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Rules | * | recommended | true | @@ -134,6 +138,7 @@ namespace NoDeprecatedContextMethods { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Rules | * | recommended | true | @@ -152,6 +157,7 @@ namespace NoDeprecatedReportApi { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | category | Tests | * | recommended | true | @@ -170,6 +176,7 @@ namespace NoIdenticalTests { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | category | Rules | * | recommended | false | * ``` @@ -187,6 +194,7 @@ namespace NoMetaSchemaDefault { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | category | Rules | * | recommended | true | * ``` @@ -204,6 +212,7 @@ namespace NoMissingMessageIds { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | category | Rules | * | recommended | true | * ``` @@ -221,6 +230,7 @@ namespace NoMissingPlaceholders { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | category | Tests | * | recommended | true | @@ -239,6 +249,7 @@ namespace NoOnlyTests { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | category | Rules | * | recommended | false | * | requiresTypeChecking | true | @@ -289,6 +300,7 @@ namespace NoPropertyInNode { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | category | Rules | * | recommended | true | * ``` @@ -306,6 +318,7 @@ namespace NoUnusedMessageIds { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | category | Rules | * | recommended | true | * ``` @@ -324,6 +337,7 @@ namespace NoUnusedPlaceholders { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Rules | * | recommended | true | @@ -343,6 +357,7 @@ namespace NoUselessTokenRange { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | category | Rules | * | recommended | true | * ``` @@ -360,6 +375,7 @@ namespace PreferMessageIds { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Rules | * | recommended | true | @@ -378,6 +394,7 @@ namespace PreferObjectRule { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Tests | * | recommended | true | @@ -396,6 +413,7 @@ namespace PreferOutputNull { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | category | Rules | * | recommended | false | * ``` @@ -413,6 +431,7 @@ namespace PreferPlaceholders { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | category | Rules | * | recommended | false | * ``` @@ -430,6 +449,7 @@ namespace PreferReplaceText { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | category | Rules | * | recommended | false | * ``` @@ -465,6 +485,7 @@ namespace ReportMessageFormat { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Rules | * | recommended | false | @@ -484,6 +505,7 @@ namespace RequireMetaDefaultOptions { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | category | Rules | * | recommended | false | * ``` @@ -531,6 +553,7 @@ namespace RequireMetaDocsDescription { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Rules | * | recommended | false | @@ -576,6 +599,7 @@ namespace RequireMetaDocsRecommended { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Rules | * | recommended | false | @@ -624,6 +648,7 @@ namespace RequireMetaDocsUrl { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | category | Rules | * | recommended | true | * ``` @@ -673,6 +698,7 @@ namespace RequireMetaFixable { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | category | Rules | * | recommended | true | @@ -691,6 +717,7 @@ namespace RequireMetaHasSuggestions { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | category | Rules | * | recommended | false | * ``` @@ -708,6 +735,7 @@ namespace RequireMetaSchemaDescription { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Rules | * | recommended | true | @@ -756,6 +784,7 @@ namespace RequireMetaSchema { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | category | Rules | * | recommended | true | * ``` @@ -773,6 +802,7 @@ namespace RequireMetaType { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Tests | * | recommended | false | @@ -812,6 +842,7 @@ namespace TestCasePropertyOrdering { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Tests | * | recommended | false | diff --git a/packages/eslint-configs/src/types/rules/eslint-prefer-arrow-functions-rules.mts b/packages/eslint-configs/src/types/rules/eslint-prefer-arrow-functions-rules.mts index c0404c3b85..f9b4af6738 100644 --- a/packages/eslint-configs/src/types/rules/eslint-prefer-arrow-functions-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-prefer-arrow-functions-rules.mts @@ -15,10 +15,11 @@ type SpreadOptionsIfIsArray< * @link https://github.com/JamieMason/prefer-arrow-functions * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferArrowFunctions { diff --git a/packages/eslint-configs/src/types/rules/eslint-promise-rules.mts b/packages/eslint-configs/src/types/rules/eslint-promise-rules.mts index 09f50d11bc..c23583ca57 100644 --- a/packages/eslint-configs/src/types/rules/eslint-promise-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-promise-rules.mts @@ -14,9 +14,10 @@ type SpreadOptionsIfIsArray< * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/param-names.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace ParamNames { @@ -58,9 +59,10 @@ namespace ParamNames { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-wrap.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoReturnWrap { @@ -98,9 +100,10 @@ namespace NoReturnWrap { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/always-return.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace AlwaysReturn { @@ -146,9 +149,10 @@ namespace AlwaysReturn { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/catch-or-return.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace CatchOrReturn { @@ -207,9 +211,10 @@ namespace CatchOrReturn { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-callbacks.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferAwaitToCallbacks { @@ -222,9 +227,10 @@ namespace PreferAwaitToCallbacks { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-then.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferAwaitToThen { @@ -261,10 +267,11 @@ namespace PreferAwaitToThen { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-catch.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferCatch { @@ -278,9 +285,10 @@ namespace PreferCatch { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-native.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoNative { @@ -294,9 +302,10 @@ namespace NoNative { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-callback-in-promise.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoCallbackInPromise { @@ -340,9 +349,10 @@ namespace NoCallbackInPromise { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-promise-in-callback.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoPromiseInCallback { @@ -355,9 +365,10 @@ namespace NoPromiseInCallback { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-nesting.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoNesting { @@ -371,9 +382,10 @@ namespace NoNesting { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/avoid-new.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace AvoidNew { @@ -386,10 +398,11 @@ namespace AvoidNew { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-new-statics.md * * ```md - * | key | value | - * | :------ | :------ | - * | type | problem | - * | fixable | code | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoNewStatics { @@ -402,9 +415,10 @@ namespace NoNewStatics { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-in-finally.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoReturnInFinally { @@ -417,9 +431,10 @@ namespace NoReturnInFinally { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/valid-params.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace ValidParams { @@ -459,9 +474,10 @@ namespace ValidParams { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-multiple-resolved.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoMultipleResolved { @@ -474,9 +490,10 @@ namespace NoMultipleResolved { * @link https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/spec-only.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace SpecOnly { diff --git a/packages/eslint-configs/src/types/rules/eslint-react-hooks-rules.mts b/packages/eslint-configs/src/types/rules/eslint-react-hooks-rules.mts index 1517f4fe9e..3f924ac288 100644 --- a/packages/eslint-configs/src/types/rules/eslint-react-hooks-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-react-hooks-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -33,6 +34,7 @@ namespace RulesOfHooks { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | diff --git a/packages/eslint-configs/src/types/rules/eslint-react-rules.mts b/packages/eslint-configs/src/types/rules/eslint-react-rules.mts index 60263becf5..64564eb486 100644 --- a/packages/eslint-configs/src/types/rules/eslint-react-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-react-rules.mts @@ -16,6 +16,7 @@ type SpreadOptionsIfIsArray< * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -78,6 +79,7 @@ namespace BooleanPropNaming { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -129,6 +131,7 @@ namespace ButtonHasType { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -170,9 +173,10 @@ namespace CheckedRequiresOnchangeOrReadonly { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/default-props-match-prop-types.md * * ```md - * | key | value | - * | :------- | :------------- | - * | category | Best Practices | + * | key | value | + * | :--------- | :------------- | + * | deprecated | false | + * | category | Best Practices | * ``` */ namespace DefaultPropsMatchPropTypes { @@ -213,6 +217,7 @@ namespace DefaultPropsMatchPropTypes { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -272,6 +277,7 @@ namespace DestructuringAssignment { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -316,6 +322,7 @@ namespace DisplayName { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -510,6 +517,7 @@ namespace ForbidComponentProps { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -585,6 +593,7 @@ namespace ForbidDomProps { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -653,6 +662,7 @@ namespace ForbidElements { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -693,6 +703,7 @@ namespace ForbidForeignPropTypes { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -746,6 +757,7 @@ namespace ForbidPropTypes { * | key | value | * | :------------- | :-------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Possible Errors | * | recommended | false | @@ -763,6 +775,7 @@ namespace ForwardRefUsesRef { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -857,6 +870,7 @@ namespace FunctionComponentDefinition { * | key | value | * | :------------- | :------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Best Practices | * | recommended | false | @@ -899,6 +913,7 @@ namespace HookUseState { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -915,6 +930,7 @@ namespace IframeMissingSandbox { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -1027,6 +1043,7 @@ namespace JsxBooleanValue { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -1043,6 +1060,7 @@ namespace JsxChildElementSpacing { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -1148,6 +1166,7 @@ namespace JsxClosingBracketLocation { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | whitespace | * | category | Stylistic Issues | * | recommended | false | @@ -1206,6 +1225,7 @@ namespace JsxClosingTagLocation { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -1351,6 +1371,7 @@ namespace JsxCurlySpacing { * | key | value | * | :---------- | :--------------- | * | type | layout | + * | deprecated | false | * | fixable | whitespace | * | category | Stylistic Issues | * | recommended | false | @@ -1417,6 +1438,7 @@ namespace JsxCurlyNewline { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -1453,6 +1475,7 @@ namespace JsxEqualsSpacing { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -1507,6 +1530,7 @@ namespace JsxFilenameExtension { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -1551,6 +1575,7 @@ namespace JsxFirstPropNewLine { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -1726,6 +1751,7 @@ namespace JsxHandlerNames { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | whitespace | * | category | Stylistic Issues | * | recommended | false | @@ -1786,6 +1812,7 @@ namespace JsxIndent { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -1858,6 +1885,7 @@ namespace JsxIndentProps { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -1909,6 +1937,7 @@ namespace JsxKey { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -1950,6 +1979,7 @@ namespace JsxMaxDepth { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -2031,6 +2061,7 @@ namespace JsxMaxPropsPerLine { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -2095,6 +2126,7 @@ namespace JsxNewline { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -2156,6 +2188,7 @@ namespace JsxNoBind { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -2173,6 +2206,7 @@ namespace JsxNoCommentTextnodes { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -2189,6 +2223,7 @@ namespace JsxNoConstructedContextValues { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -2229,6 +2264,7 @@ namespace JsxNoDuplicateProps { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | fixable | code | * | category | Possible Errors | * | recommended | false | @@ -2281,6 +2317,7 @@ namespace JsxNoLeakedRender { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -2377,6 +2414,7 @@ namespace JsxNoLiterals { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -2482,6 +2520,7 @@ namespace JsxNoScriptUrl { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | true | @@ -2545,6 +2584,7 @@ namespace JsxNoTargetBlank { * | key | value | * | :---------- | :-------------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | category | Possible Errors | * | recommended | false | @@ -2586,6 +2626,7 @@ namespace JsxNoUselessFragment { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | whitespace | * | category | Stylistic Issues | * | recommended | false | @@ -2635,6 +2676,7 @@ namespace JsxOneExpressionPerLine { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -2676,6 +2718,7 @@ namespace JsxNoUndef { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -2750,6 +2793,7 @@ namespace JsxCurlyBracePresence { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -2810,6 +2854,7 @@ namespace JsxPascalCase { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -2846,6 +2891,7 @@ namespace JsxFragments { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -2863,6 +2909,7 @@ namespace JsxPropsNoMultiSpaces { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -2958,6 +3005,7 @@ namespace JsxPropsNoSpreading { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -3008,6 +3056,7 @@ namespace JsxSortDefaultProps { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -3118,6 +3167,7 @@ namespace JsxSpaceBeforeClosing { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | whitespace | * | category | Stylistic Issues | * | recommended | false | @@ -3204,6 +3254,7 @@ namespace JsxTagSpacing { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -3220,6 +3271,7 @@ namespace JsxUsesReact { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -3236,6 +3288,7 @@ namespace JsxUsesVars { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -3393,6 +3446,7 @@ namespace JsxWrapMultilines { * | key | value | * | :------------- | :-------------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | category | Possible Errors | * ``` @@ -3431,6 +3485,7 @@ namespace NoInvalidHtmlAttribute { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -3447,6 +3502,7 @@ namespace NoAccessStateInSetstate { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -3463,6 +3519,7 @@ namespace NoAdjacentInlineElements { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -3479,6 +3536,7 @@ namespace NoArrayIndexKey { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | fixable | code | * | category | Best Practices | * | recommended | false | @@ -3496,6 +3554,7 @@ namespace NoArrowFunctionLifecycle { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -3537,6 +3596,7 @@ namespace NoChildrenProp { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -3584,6 +3644,7 @@ namespace NoDanger { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -3600,6 +3661,7 @@ namespace NoDangerWithChildren { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -3616,6 +3678,7 @@ namespace NoDeprecated { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -3650,6 +3713,7 @@ namespace NoDidMountSetState { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -3684,6 +3748,7 @@ namespace NoDidUpdateSetState { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -3700,6 +3765,7 @@ namespace NoDirectMutationState { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -3716,6 +3782,7 @@ namespace NoFindDomNode { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -3732,6 +3799,7 @@ namespace NoIsMounted { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -3773,6 +3841,7 @@ namespace NoMultiComp { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -3789,6 +3858,7 @@ namespace NoNamespace { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -3805,6 +3875,7 @@ namespace NoSetState { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -3845,6 +3916,7 @@ namespace NoStringRefs { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -3861,6 +3933,7 @@ namespace NoRedundantShouldComponentUpdate { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -3877,6 +3950,7 @@ namespace NoRenderReturnValue { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -3893,6 +3967,7 @@ namespace NoThisInSfc { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -3909,6 +3984,7 @@ namespace NoTypos { * ```md * | key | value | * | :------------- | :-------------- | + * | deprecated | false | * | hasSuggestions | true | * | category | Possible Errors | * | recommended | true | @@ -3979,6 +4055,7 @@ namespace NoUnescapedEntities { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | fixable | code | * | category | Possible Errors | * | recommended | true | @@ -4028,6 +4105,7 @@ namespace NoUnknownProperty { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -4069,6 +4147,7 @@ namespace NoUnsafe { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -4120,6 +4199,7 @@ namespace NoUnstableNestedComponents { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -4136,6 +4216,7 @@ namespace NoUnusedClassComponentMethods { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -4191,6 +4272,7 @@ namespace NoUnusedPropTypes { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -4208,6 +4290,7 @@ namespace NoUnusedState { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -4224,6 +4307,7 @@ namespace NoObjectTypeAsDefaultProp { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -4258,6 +4342,7 @@ namespace NoWillUpdateSetState { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -4293,6 +4378,7 @@ namespace PreferEs6Class { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -4309,6 +4395,7 @@ namespace PreferExactProps { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -4326,6 +4413,7 @@ namespace PreferReadOnlyProps { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -4367,6 +4455,7 @@ namespace PreferStatelessFunction { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | true | * ``` @@ -4421,6 +4510,7 @@ namespace PropTypes { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -4435,9 +4525,10 @@ namespace ReactInJsxScope { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/require-default-props.md * * ```md - * | key | value | - * | :------- | :------------- | - * | category | Best Practices | + * | key | value | + * | :--------- | :------------- | + * | deprecated | false | + * | category | Best Practices | * ``` */ namespace RequireDefaultProps { @@ -4495,6 +4586,7 @@ namespace RequireDefaultProps { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` @@ -4538,6 +4630,7 @@ namespace RequireOptimization { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | true | * ``` @@ -4554,6 +4647,7 @@ namespace RequireRenderReturn { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -4601,6 +4695,7 @@ namespace SelfClosingComp { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -4656,6 +4751,7 @@ namespace SortComp { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -4696,6 +4792,7 @@ namespace SortDefaultProps { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | fixable | code | * | category | Stylistic Issues | * | recommended | false | @@ -4757,6 +4854,7 @@ namespace SortPropTypes { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -4792,6 +4890,7 @@ namespace StateInConstructor { * ```md * | key | value | * | :---------- | :--------------- | + * | deprecated | false | * | category | Stylistic Issues | * | recommended | false | * ``` @@ -4907,6 +5006,7 @@ namespace StaticPropertyPlacement { * ```md * | key | value | * | :---------- | :-------------- | + * | deprecated | false | * | category | Possible Errors | * | recommended | false | * ``` @@ -4952,6 +5052,7 @@ namespace StylePropObject { * ```md * | key | value | * | :---------- | :------------- | + * | deprecated | false | * | category | Best Practices | * | recommended | false | * ``` diff --git a/packages/eslint-configs/src/types/rules/eslint-rules.mts b/packages/eslint-configs/src/types/rules/eslint-rules.mts index c3c638b014..defefd6e27 100644 --- a/packages/eslint-configs/src/types/rules/eslint-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -165,6 +166,7 @@ namespace ArrayBracketSpacing { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -285,6 +287,7 @@ namespace ArrayElementNewline { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -437,6 +440,7 @@ namespace ArrowSpacing { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -560,6 +564,7 @@ namespace CallbackReturn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -625,6 +630,7 @@ namespace Camelcase { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -736,6 +742,7 @@ namespace CapitalizedComments { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -939,6 +946,7 @@ namespace CommaStyle { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1044,6 +1052,7 @@ namespace ComputedPropertySpacing { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1084,6 +1093,7 @@ namespace ConsistentReturn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1119,6 +1129,7 @@ namespace ConsistentThis { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1135,6 +1146,7 @@ namespace ConstructorSuper { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -1194,6 +1206,7 @@ namespace Curly { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1234,6 +1247,7 @@ namespace DefaultCase { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1250,6 +1264,7 @@ namespace DefaultCaseLast { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1298,6 +1313,7 @@ namespace DotLocation { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -1377,6 +1393,7 @@ namespace EolLast { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -1445,6 +1462,7 @@ namespace Eqeqeq { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1520,6 +1538,7 @@ namespace FuncCallSpacing { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1605,6 +1624,7 @@ namespace FuncNameMatching { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1663,6 +1683,7 @@ namespace FuncNames { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1932,6 +1953,7 @@ namespace GeneratorStarSpacing { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1989,6 +2011,7 @@ namespace GlobalRequire { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -2025,6 +2048,7 @@ namespace GroupedAccessorPairs { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -2099,6 +2123,7 @@ namespace IdBlacklist { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -2133,6 +2158,7 @@ namespace IdDenylist { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -2200,6 +2226,7 @@ namespace IdLength { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -2743,6 +2770,7 @@ namespace IndentLegacy { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -4249,6 +4277,7 @@ namespace LinesBetweenClassMembers { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | false | @@ -4320,6 +4349,7 @@ namespace LogicalAssignmentOperators { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -4375,6 +4405,7 @@ namespace MaxClassesPerFile { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -4589,6 +4620,7 @@ namespace MaxLen { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -4648,6 +4680,7 @@ namespace MaxLines { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -4711,6 +4744,7 @@ namespace MaxLinesPerFunction { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -4767,6 +4801,7 @@ namespace MaxNestedCallbacks { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -4823,6 +4858,7 @@ namespace MaxParams { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5017,6 +5053,7 @@ namespace MultilineTernary { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5207,6 +5244,7 @@ namespace NewlinePerChainedCall { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5223,6 +5261,7 @@ namespace NoAlert { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -5240,6 +5279,7 @@ namespace NoArrayConstructor { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5256,6 +5296,7 @@ namespace NoAsyncPromiseExecutor { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5272,6 +5313,7 @@ namespace NoAwaitInLoop { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5365,6 +5407,7 @@ namespace NoBufferConstructor { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5381,6 +5424,7 @@ namespace NoCaller { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -5416,6 +5460,7 @@ namespace NoCatchShadow { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5432,6 +5477,7 @@ namespace NoClassAssign { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5448,6 +5494,7 @@ namespace NoCompareNegZero { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5523,6 +5570,7 @@ namespace NoConfusingArrow { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -5570,6 +5618,7 @@ namespace NoConsole { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5586,6 +5635,7 @@ namespace NoConstAssign { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5602,6 +5652,7 @@ namespace NoConstantBinaryExpression { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5648,6 +5699,7 @@ namespace NoConstantCondition { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5664,6 +5716,7 @@ namespace NoConstructorReturn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5680,6 +5733,7 @@ namespace NoContinue { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5696,6 +5750,7 @@ namespace NoControlRegex { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5712,6 +5767,7 @@ namespace NoDebugger { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5728,6 +5784,7 @@ namespace NoDeleteVar { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -5745,6 +5802,7 @@ namespace NoDivRegex { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5761,6 +5819,7 @@ namespace NoDupeArgs { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5777,6 +5836,7 @@ namespace NoDupeClassMembers { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5793,6 +5853,7 @@ namespace NoDupeElseIf { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5809,6 +5870,7 @@ namespace NoDupeKeys { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5825,6 +5887,7 @@ namespace NoDuplicateCase { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -5865,6 +5928,7 @@ namespace NoDuplicateImports { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -5906,6 +5970,7 @@ namespace NoElseReturn { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -5947,6 +6012,7 @@ namespace NoEmpty { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -5963,6 +6029,7 @@ namespace NoEmptyCharacterClass { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6029,6 +6096,7 @@ namespace NoEmptyFunction { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6069,6 +6137,7 @@ namespace NoEmptyPattern { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6085,6 +6154,7 @@ namespace NoEmptyStaticBlock { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6101,6 +6171,7 @@ namespace NoEqNull { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6141,6 +6212,7 @@ namespace NoEval { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6157,6 +6229,7 @@ namespace NoExAssign { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6201,6 +6274,7 @@ namespace NoExtendNative { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -6218,6 +6292,7 @@ namespace NoExtraBind { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -6276,6 +6351,7 @@ namespace NoExtraBooleanCast { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -6395,6 +6471,7 @@ namespace NoExtraSemi { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6461,6 +6538,7 @@ namespace NoFloatingDecimal { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6477,6 +6555,7 @@ namespace NoFuncAssign { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6521,6 +6600,7 @@ namespace NoGlobalAssign { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | false | @@ -6590,6 +6670,7 @@ namespace NoImplicitCoercion { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6630,6 +6711,7 @@ namespace NoImplicitGlobals { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6646,6 +6728,7 @@ namespace NoImpliedEval { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6662,6 +6745,7 @@ namespace NoImportAssign { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6702,6 +6786,7 @@ namespace NoInlineComments { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6754,6 +6839,7 @@ namespace NoInnerDeclarations { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6797,6 +6883,7 @@ namespace NoInvalidRegexp { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6837,6 +6924,7 @@ namespace NoInvalidThis { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -6893,6 +6981,7 @@ namespace NoIrregularWhitespace { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6909,6 +6998,7 @@ namespace NoIterator { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6925,6 +7015,7 @@ namespace NoLabelVar { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6969,6 +7060,7 @@ namespace NoLabels { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -6985,6 +7077,7 @@ namespace NoLoneBlocks { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -7003,6 +7096,7 @@ namespace NoLonelyIf { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7019,6 +7113,7 @@ namespace NoLoopFunc { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -7035,6 +7130,7 @@ namespace NoLossOfPrecision { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7113,6 +7209,7 @@ namespace NoMagicNumbers { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -7306,6 +7403,7 @@ namespace NoMixedSpacesAndTabs { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7391,6 +7489,7 @@ namespace NoMultiSpaces { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7492,6 +7591,7 @@ namespace NoNativeReassign { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7525,6 +7625,7 @@ namespace NoNegatedInLhs { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7541,6 +7642,7 @@ namespace NoNestedTernary { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7557,6 +7659,7 @@ namespace NoNew { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7573,6 +7676,7 @@ namespace NoNewFunc { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -7640,6 +7744,7 @@ namespace NoNewSymbol { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7656,6 +7761,7 @@ namespace NoNewWrappers { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -7673,6 +7779,7 @@ namespace NoNonoctalDecimalEscape { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -7689,6 +7796,7 @@ namespace NoObjCalls { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -7706,6 +7814,7 @@ namespace NoObjectConstructor { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -7722,6 +7831,7 @@ namespace NoOctal { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7738,6 +7848,7 @@ namespace NoOctalEscape { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7832,6 +7943,7 @@ namespace NoPathConcat { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7906,6 +8018,7 @@ namespace NoProcessExit { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -7947,6 +8060,7 @@ namespace NoPromiseExecutorReturn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -7963,6 +8077,7 @@ namespace NoProto { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -7980,6 +8095,7 @@ namespace NoPrototypeBuiltins { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -8020,6 +8136,7 @@ namespace NoRedeclare { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -8037,6 +8154,7 @@ namespace NoRegexSpaces { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8139,6 +8257,7 @@ namespace NoRestrictedExports { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8198,6 +8317,7 @@ namespace NoRestrictedGlobals { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8542,6 +8662,7 @@ namespace NoRestrictedModules { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8620,6 +8741,7 @@ namespace NoRestrictedProperties { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8679,6 +8801,7 @@ namespace NoRestrictedSyntax { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8732,6 +8855,7 @@ namespace NoReturnAwait { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8748,6 +8872,7 @@ namespace NoScriptUrl { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -8788,6 +8913,7 @@ namespace NoSelfAssign { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8804,6 +8930,7 @@ namespace NoSelfCompare { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8844,6 +8971,7 @@ namespace NoSequences { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -8861,6 +8989,7 @@ namespace NoSetterReturn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -8920,6 +9049,7 @@ namespace NoShadow { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -8955,6 +9085,7 @@ namespace NoSpacedFunc { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9041,6 +9172,7 @@ namespace NoTabs { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9057,6 +9189,7 @@ namespace NoTemplateCurlyInString { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9073,6 +9206,7 @@ namespace NoTernary { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9089,6 +9223,7 @@ namespace NoThisBeforeSuper { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9146,6 +9281,7 @@ namespace NoTrailingSpaces { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9186,6 +9322,7 @@ namespace NoUndef { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -9203,6 +9340,7 @@ namespace NoUndefInit { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9219,6 +9357,7 @@ namespace NoUndefined { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9294,6 +9433,7 @@ namespace NoUnderscoreDangle { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9310,6 +9450,7 @@ namespace NoUnexpectedMultiline { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9326,6 +9467,7 @@ namespace NoUnmodifiedLoopCondition { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -9368,6 +9510,7 @@ namespace NoUnneededTernary { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9384,6 +9527,7 @@ namespace NoUnreachable { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9440,6 +9584,7 @@ namespace NoUnreachableLoop { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9456,6 +9601,7 @@ namespace NoUnsafeFinally { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -9498,6 +9644,7 @@ namespace NoUnsafeNegation { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9538,6 +9685,7 @@ namespace NoUnsafeOptionalChaining { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9590,6 +9738,7 @@ namespace NoUnusedExpressions { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -9607,6 +9756,7 @@ namespace NoUnusedLabels { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9623,6 +9773,7 @@ namespace NoUnusedPrivateClassMembers { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -9723,6 +9874,7 @@ namespace NoUnusedVars { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9786,6 +9938,7 @@ namespace NoUseBeforeDefine { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9802,6 +9955,7 @@ namespace NoUselessAssignment { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9818,6 +9972,7 @@ namespace NoUselessBackreference { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9834,6 +9989,7 @@ namespace NoUselessCall { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -9850,6 +10006,7 @@ namespace NoUselessCatch { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -9891,6 +10048,7 @@ namespace NoUselessComputedKey { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -9907,6 +10065,7 @@ namespace NoUselessConcat { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -9924,6 +10083,7 @@ namespace NoUselessConstructor { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -9942,6 +10102,7 @@ namespace NoUselessEscape { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -9991,6 +10152,7 @@ namespace NoUselessRename { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -10008,6 +10170,7 @@ namespace NoUselessReturn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -10025,6 +10188,7 @@ namespace NoVar { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -10065,6 +10229,7 @@ namespace NoVoid { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -10144,6 +10309,7 @@ namespace NoWhitespaceBeforeProperty { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -10494,6 +10660,7 @@ namespace ObjectPropertyNewline { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -10616,6 +10783,7 @@ namespace ObjectShorthand { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -10752,6 +10920,7 @@ namespace OneVarDeclarationPerLine { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11050,6 +11219,7 @@ namespace PaddingLineBetweenStatements { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11096,6 +11266,7 @@ namespace PreferArrowCallback { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11144,6 +11315,7 @@ namespace PreferConst { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11248,6 +11420,7 @@ namespace PreferDestructuring { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11265,6 +11438,7 @@ namespace PreferExponentiationOperator { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -11283,6 +11457,7 @@ namespace PreferNamedCaptureGroup { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11301,6 +11476,7 @@ namespace PreferNumericLiterals { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11319,6 +11495,7 @@ namespace PreferObjectHasOwn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11336,6 +11513,7 @@ namespace PreferObjectSpread { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -11426,6 +11604,7 @@ namespace PreferReflect { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -11467,6 +11646,7 @@ namespace PreferRegexLiterals { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -11483,6 +11663,7 @@ namespace PreferRestParams { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -11499,6 +11680,7 @@ namespace PreferSpread { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -11643,6 +11825,7 @@ namespace Quotes { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -11680,6 +11863,7 @@ namespace Radix { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | false | * ``` */ @@ -11720,6 +11904,7 @@ namespace RequireAtomicUpdates { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -11737,6 +11922,7 @@ namespace RequireAwait { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -11781,6 +11967,7 @@ namespace RequireUnicodeRegexp { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -11970,6 +12157,7 @@ namespace SemiStyle { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -12047,6 +12235,7 @@ namespace SortImports { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -12113,6 +12302,7 @@ namespace SortKeys { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -12502,6 +12692,7 @@ namespace SpacedComment { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -12580,6 +12771,7 @@ namespace SwitchColonSpacing { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -12660,6 +12852,7 @@ namespace TemplateTagSpacing { * | key | value | * | :---------- | :--------- | * | type | layout | + * | deprecated | false | * | fixable | whitespace | * | recommended | false | * ``` @@ -12696,6 +12889,7 @@ namespace UnicodeBom { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -12741,6 +12935,7 @@ namespace UseIsnan { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -12782,6 +12977,7 @@ namespace ValidTypeof { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -12909,6 +13105,7 @@ namespace YieldStarSpacing { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` diff --git a/packages/eslint-configs/src/types/rules/eslint-security-rules.mts b/packages/eslint-configs/src/types/rules/eslint-security-rules.mts index 36c644396b..6a7276fbeb 100644 --- a/packages/eslint-configs/src/types/rules/eslint-security-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-security-rules.mts @@ -11,6 +11,7 @@ import { type Linter } from 'eslint'; * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -29,6 +30,7 @@ namespace DetectUnsafeRegex { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -47,6 +49,7 @@ namespace DetectNonLiteralRegexp { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -65,6 +68,7 @@ namespace DetectNonLiteralRequire { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -83,6 +87,7 @@ namespace DetectNonLiteralFsFilename { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -101,6 +106,7 @@ namespace DetectEvalWithExpression { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -119,6 +125,7 @@ namespace DetectPseudoRandomBytes { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -136,6 +143,7 @@ namespace DetectPossibleTimingAttacks { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -153,6 +161,7 @@ namespace DetectNoCsrfBeforeMethodOverride { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -170,6 +179,7 @@ namespace DetectBufferNoassert { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -188,6 +198,7 @@ namespace DetectChildProcess { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -205,6 +216,7 @@ namespace DetectDisableMustacheEscape { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -223,6 +235,7 @@ namespace DetectObjectInjection { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` @@ -241,6 +254,7 @@ namespace DetectNewBuffer { * | key | value | * | :---------- | :------------------------------ | * | type | error | + * | deprecated | false | * | category | Possible Security Vulnerability | * | recommended | true | * ``` diff --git a/packages/eslint-configs/src/types/rules/eslint-testing-library-rules.mts b/packages/eslint-configs/src/types/rules/eslint-testing-library-rules.mts index e50c811ca3..9e37f25616 100644 --- a/packages/eslint-configs/src/types/rules/eslint-testing-library-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-testing-library-rules.mts @@ -14,10 +14,11 @@ type SpreadOptionsIfIsArray< * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/await-async-events.md * * ```md - * | key | value | - * | :------ | :------ | - * | type | problem | - * | fixable | code | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | * ``` */ namespace AwaitAsyncEvents { @@ -77,9 +78,10 @@ namespace AwaitAsyncEvents { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/await-async-queries.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace AwaitAsyncQueries { @@ -92,9 +94,10 @@ namespace AwaitAsyncQueries { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/await-async-utils.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace AwaitAsyncUtils { @@ -107,9 +110,10 @@ namespace AwaitAsyncUtils { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/consistent-data-testid.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace ConsistentDataTestid { @@ -169,9 +173,10 @@ namespace ConsistentDataTestid { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-await-sync-events.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoAwaitSyncEvents { @@ -223,9 +228,10 @@ namespace NoAwaitSyncEvents { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-await-sync-queries.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoAwaitSyncQueries { @@ -238,9 +244,10 @@ namespace NoAwaitSyncQueries { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-container.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoContainer { @@ -253,9 +260,10 @@ namespace NoContainer { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-debugging-utils.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoDebuggingUtils { @@ -320,10 +328,11 @@ namespace NoDebuggingUtils { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-dom-import.md * * ```md - * | key | value | - * | :------ | :------ | - * | type | problem | - * | fixable | code | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoDomImport { @@ -352,10 +361,11 @@ namespace NoDomImport { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-global-regexp-flag-in-query.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoGlobalRegexpFlagInQuery { @@ -368,9 +378,10 @@ namespace NoGlobalRegexpFlagInQuery { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-manual-cleanup.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoManualCleanup { @@ -383,9 +394,10 @@ namespace NoManualCleanup { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-node-access.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoNodeAccess { @@ -422,9 +434,10 @@ namespace NoNodeAccess { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-promise-in-fire-event.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoPromiseInFireEvent { @@ -437,9 +450,10 @@ namespace NoPromiseInFireEvent { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-render-in-lifecycle.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoRenderInLifecycle { @@ -480,9 +494,10 @@ namespace NoRenderInLifecycle { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-unnecessary-act.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoUnnecessaryAct { @@ -519,9 +534,10 @@ namespace NoUnnecessaryAct { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-wait-for-multiple-assertions.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoWaitForMultipleAssertions { @@ -534,9 +550,10 @@ namespace NoWaitForMultipleAssertions { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-wait-for-side-effects.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoWaitForSideEffects { @@ -549,9 +566,10 @@ namespace NoWaitForSideEffects { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/no-wait-for-snapshot.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoWaitForSnapshot { @@ -564,9 +582,10 @@ namespace NoWaitForSnapshot { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/prefer-explicit-assert.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferExplicitAssert { @@ -618,10 +637,11 @@ namespace PreferExplicitAssert { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/prefer-find-by.md * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace PreferFindBy { @@ -634,9 +654,10 @@ namespace PreferFindBy { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/prefer-implicit-assert.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferImplicitAssert { @@ -650,9 +671,10 @@ namespace PreferImplicitAssert { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/prefer-presence-queries.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferPresenceQueries { @@ -693,9 +715,10 @@ namespace PreferPresenceQueries { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/prefer-query-by-disappearance.md * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace PreferQueryByDisappearance { @@ -709,9 +732,10 @@ namespace PreferQueryByDisappearance { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/prefer-query-matchers.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferQueryMatchers { @@ -767,9 +791,10 @@ namespace PreferQueryMatchers { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/prefer-screen-queries.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferScreenQueries { @@ -782,9 +807,10 @@ namespace PreferScreenQueries { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/prefer-user-event.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferUserEvent { @@ -821,9 +847,10 @@ namespace PreferUserEvent { * @link https://github.com/testing-library/eslint-plugin-testing-library/tree/main/docs/rules/render-result-naming-convention.md * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace RenderResultNamingConvention { diff --git a/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts b/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts index 0c14a58984..6d7ebd4ada 100644 --- a/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts @@ -10,6 +10,7 @@ import { type Linter } from 'eslint'; * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -26,6 +27,7 @@ namespace RequireStrictMode { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -42,6 +44,7 @@ namespace NoUnsafeTypeAssertion { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -58,6 +61,7 @@ namespace NoUnsafeReadonlyMutableAssignment { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -74,6 +78,7 @@ namespace NoUnsafeMutableReadonlyAssignment { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -90,6 +95,7 @@ namespace NoEnums { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -106,6 +112,7 @@ namespace NoPartialUrlConstructor { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -122,6 +129,7 @@ namespace NoPartialDivision { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -138,6 +146,7 @@ namespace NoPartialStringNormalize { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -154,6 +163,7 @@ namespace NoPrematureFpTsEffects { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -170,6 +180,7 @@ namespace NoNestedFpTsEffects { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -186,6 +197,7 @@ namespace NoPartialArrayReduce { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ diff --git a/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts b/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts index 8391e1263e..42c8cee243 100644 --- a/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts @@ -8,6 +8,7 @@ import { type Linter } from 'eslint'; * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ diff --git a/packages/eslint-configs/src/types/rules/eslint-unicorn-rules.mts b/packages/eslint-configs/src/types/rules/eslint-unicorn-rules.mts index 45a442dc62..b50bb2a698 100644 --- a/packages/eslint-configs/src/types/rules/eslint-unicorn-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-unicorn-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -59,6 +60,7 @@ namespace BetterRegex { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -105,6 +107,7 @@ namespace CatchErrorName { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | false | @@ -123,6 +126,7 @@ namespace ConsistentDestructuring { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -141,6 +145,7 @@ namespace ConsistentEmptyArraySpread { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -158,6 +163,7 @@ namespace ConsistentExistenceIndexCheck { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -199,6 +205,7 @@ namespace ConsistentFunctionScoping { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -216,6 +223,7 @@ namespace CustomErrorDefinition { * | key | value | * | :---------- | :--------- | * | type | layout | + * | deprecated | false | * | fixable | whitespace | * | recommended | true | * ``` @@ -233,6 +241,7 @@ namespace EmptyBraceSpaces { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -249,6 +258,7 @@ namespace ErrorMessage { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -266,6 +276,7 @@ namespace EscapeCase { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -329,6 +340,7 @@ namespace ExpiringTodoComments { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -375,6 +387,7 @@ namespace ExplicitLengthCheck { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -472,6 +485,7 @@ namespace FilenameCase { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -571,6 +585,7 @@ namespace ImportStyle { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -588,6 +603,7 @@ namespace NewForBuiltins { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -604,6 +620,7 @@ namespace NoAbusiveEslintDisable { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -621,6 +638,7 @@ namespace NoAnonymousDefaultExport { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -638,6 +656,7 @@ namespace NoArrayCallbackReference { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -656,6 +675,7 @@ namespace NoArrayForEach { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -674,6 +694,7 @@ namespace NoArrayMethodThisArgument { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -717,6 +738,7 @@ namespace NoArrayPushPush { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -758,6 +780,7 @@ namespace NoArrayReduce { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -775,6 +798,7 @@ namespace NoAwaitExpressionMember { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -792,6 +816,7 @@ namespace NoAwaitInPromiseMethods { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -809,6 +834,7 @@ namespace NoConsoleSpaces { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -825,6 +851,7 @@ namespace NoDocumentCookie { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -841,6 +868,7 @@ namespace NoEmptyFile { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -859,6 +887,7 @@ namespace NoForLoop { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -876,6 +905,7 @@ namespace NoHexEscape { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -893,6 +923,7 @@ namespace NoInstanceofArray { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -910,6 +941,7 @@ namespace NoInvalidFetchOptions { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -926,6 +958,7 @@ namespace NoInvalidRemoveEventListener { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -983,6 +1016,7 @@ namespace NoKeywordPrefix { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1000,6 +1034,7 @@ namespace NoLengthAsSliceEnd { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1017,6 +1052,7 @@ namespace NoLonelyIf { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1033,6 +1069,7 @@ namespace NoMagicArrayFlatDepth { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1050,6 +1087,7 @@ namespace NoNegatedCondition { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -1067,6 +1105,7 @@ namespace NoNegationInEqualityCheck { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1084,6 +1123,7 @@ namespace NoNestedTernary { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1103,6 +1143,7 @@ namespace NoNewArray { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1121,6 +1162,7 @@ namespace NoNewBuffer { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1164,6 +1206,7 @@ namespace NoNull { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1180,6 +1223,7 @@ namespace NoObjectAsDefaultParameter { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1196,6 +1240,7 @@ namespace NoProcessExit { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1214,6 +1259,7 @@ namespace NoSinglePromiseInPromiseMethods { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1231,6 +1277,7 @@ namespace NoStaticOnlyClass { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1247,6 +1294,7 @@ namespace NoThenable { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1263,6 +1311,7 @@ namespace NoThisAssignment { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1306,6 +1355,7 @@ namespace NoTypeofUndefined { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1323,6 +1373,7 @@ namespace NoUnnecessaryAwait { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1376,6 +1427,7 @@ namespace NoUnnecessaryPolyfills { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1393,6 +1445,7 @@ namespace NoUnreadableArrayDestructuring { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | false | * | recommended | true | * ``` @@ -1410,6 +1463,7 @@ namespace NoUnreadableIife { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | false | * ``` */ @@ -1426,6 +1480,7 @@ namespace NoUnusedProperties { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1443,6 +1498,7 @@ namespace NoUselessFallbackInSpread { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1461,6 +1517,7 @@ namespace NoUselessLengthCheck { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1478,6 +1535,7 @@ namespace NoUselessPromiseResolveReject { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1495,6 +1553,7 @@ namespace NoUselessSpread { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -1512,6 +1571,7 @@ namespace NoUselessSwitchCase { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1557,6 +1617,7 @@ namespace NoUselessUndefined { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1574,6 +1635,7 @@ namespace NoZeroFractions { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1591,6 +1653,7 @@ namespace NumberLiteralCase { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1730,6 +1793,7 @@ namespace NumericSeparatorsStyle { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1776,6 +1840,7 @@ namespace PreferAddEventListener { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1819,6 +1884,7 @@ namespace PreferArrayFind { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1836,6 +1902,7 @@ namespace PreferArrayFlatMap { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -1879,6 +1946,7 @@ namespace PreferArrayFlat { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1898,6 +1966,7 @@ namespace PreferArrayIndexOf { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1916,6 +1985,7 @@ namespace PreferArraySome { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -1965,6 +2035,7 @@ namespace PreferAt { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -1982,6 +2053,7 @@ namespace PreferBlobReadingMethods { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -1999,6 +2071,7 @@ namespace PreferCodePoint { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2016,6 +2089,7 @@ namespace PreferDateNow { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2034,6 +2108,7 @@ namespace PreferDefaultParameters { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2051,6 +2126,7 @@ namespace PreferDomNodeAppend { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2068,6 +2144,7 @@ namespace PreferDomNodeDataset { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2086,6 +2163,7 @@ namespace PreferDomNodeRemove { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -2103,6 +2181,7 @@ namespace PreferDomNodeTextContent { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | true | * ``` */ @@ -2119,6 +2198,7 @@ namespace PreferEventTarget { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2162,6 +2242,7 @@ namespace PreferExportFrom { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | false | * | recommended | true | @@ -2181,6 +2262,7 @@ namespace PreferGlobalThis { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2199,6 +2281,7 @@ namespace PreferIncludes { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | false | * ``` @@ -2216,6 +2299,7 @@ namespace PreferJsonParseBuffer { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2233,6 +2317,7 @@ namespace PreferKeyboardEventKey { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -2250,6 +2335,7 @@ namespace PreferLogicalOperatorOverTernary { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2267,6 +2353,7 @@ namespace PreferMathMinMax { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2287,6 +2374,7 @@ namespace PreferMathTrunc { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2304,6 +2392,7 @@ namespace PreferModernDomApis { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2321,6 +2410,7 @@ namespace PreferModernMathApis { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2339,6 +2429,7 @@ namespace PreferModule { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2356,6 +2447,7 @@ namespace PreferNativeCoercionFunctions { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2373,6 +2465,7 @@ namespace PreferNegativeIndex { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2390,6 +2483,7 @@ namespace PreferNodeProtocol { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2439,6 +2533,7 @@ namespace PreferNumberProperties { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2481,6 +2576,7 @@ namespace PreferObjectFromEntries { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2498,6 +2594,7 @@ namespace PreferOptionalCatchBinding { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2517,6 +2614,7 @@ namespace PreferPrototypeMethods { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2534,6 +2632,7 @@ namespace PreferQuerySelector { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2551,6 +2650,7 @@ namespace PreferReflectApply { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2570,6 +2670,7 @@ namespace PreferRegexpTest { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2588,6 +2689,7 @@ namespace PreferSetHas { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2606,6 +2708,7 @@ namespace PreferSetSize { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2624,6 +2727,7 @@ namespace PreferSpread { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2641,6 +2745,7 @@ namespace PreferStringRaw { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2658,6 +2763,7 @@ namespace PreferStringReplaceAll { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2675,6 +2781,7 @@ namespace PreferStringSlice { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -2694,6 +2801,7 @@ namespace PreferStringStartsEndsWith { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2711,6 +2819,7 @@ namespace PreferStringTrimStartEnd { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -2753,6 +2862,7 @@ namespace PreferStructuredClone { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2808,6 +2918,7 @@ namespace PreferSwitch { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2845,6 +2956,7 @@ namespace PreferTernary { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | true | * ``` @@ -2862,6 +2974,7 @@ namespace PreferTopLevelAwait { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2879,6 +2992,7 @@ namespace PreferTypeError { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -2999,6 +3113,7 @@ namespace PreventAbbreviations { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -3037,6 +3152,7 @@ namespace RelativeUrlStyle { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -3054,6 +3170,7 @@ namespace RequireArrayJoinSeparator { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -3071,6 +3188,7 @@ namespace RequireNumberToFixedDigitsArgument { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | false | * ``` @@ -3088,6 +3206,7 @@ namespace RequirePostMessageTargetOrigin { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | false | @@ -3163,6 +3282,7 @@ namespace StringContent { * | key | value | * | :---------- | :----- | * | type | layout | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -3199,6 +3319,7 @@ namespace SwitchCaseBraces { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` @@ -3281,6 +3402,7 @@ namespace TemplateIndent { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | true | @@ -3299,6 +3421,7 @@ namespace TextEncodingIdentifierCase { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | true | * ``` diff --git a/packages/eslint-configs/src/types/rules/eslint-vitest-rules.mts b/packages/eslint-configs/src/types/rules/eslint-vitest-rules.mts index e351061fda..8e19a1d1cf 100644 --- a/packages/eslint-configs/src/types/rules/eslint-vitest-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-vitest-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -84,6 +85,7 @@ namespace PreferLowercaseTitle { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -124,6 +126,7 @@ namespace MaxNestedDescribe { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -141,6 +144,7 @@ namespace NoIdenticalTitle { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -183,6 +187,7 @@ namespace NoFocusedTests { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -199,6 +204,7 @@ namespace NoConditionalTests { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -251,6 +257,7 @@ namespace ExpectExpect { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -304,6 +311,7 @@ namespace ConsistentTestIt { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -321,6 +329,7 @@ namespace PreferToBe { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -367,6 +376,7 @@ namespace NoHooks { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -405,6 +415,7 @@ namespace NoRestrictedViMethods { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | false | * ``` @@ -452,6 +463,7 @@ namespace ConsistentTestFilename { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | false | * ``` @@ -493,6 +505,7 @@ namespace MaxExpects { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * | requiresTypeChecking | false | @@ -511,6 +524,7 @@ namespace NoAliasMethods { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | false | * ``` @@ -528,6 +542,7 @@ namespace NoCommentedOutTests { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | false | * ``` @@ -545,6 +560,7 @@ namespace NoConditionalExpect { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | false | * ``` @@ -562,6 +578,7 @@ namespace NoConditionalInTest { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -596,6 +613,7 @@ namespace NoDoneCallback { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | false | * ``` @@ -613,6 +631,7 @@ namespace NoDuplicateHooks { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -664,6 +683,7 @@ namespace NoLargeSnapshots { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -681,6 +701,7 @@ namespace NoInterpolationInSnapshots { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | error | * ``` */ @@ -697,6 +718,7 @@ namespace NoMocksImport { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -735,6 +757,7 @@ namespace NoRestrictedMatchers { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -777,6 +800,7 @@ namespace NoStandaloneExpect { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -794,6 +818,7 @@ namespace NoTestPrefixes { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -810,6 +835,7 @@ namespace NoTestReturnStatement { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -827,6 +853,7 @@ namespace NoImportNodeTest { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -844,6 +871,7 @@ namespace PreferCalledWith { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -949,6 +977,7 @@ namespace ValidTitle { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1007,6 +1036,7 @@ namespace ValidExpect { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1024,6 +1054,7 @@ namespace PreferToBeFalsy { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1041,6 +1072,7 @@ namespace PreferToBeObject { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1058,6 +1090,7 @@ namespace PreferToBeTruthy { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1075,6 +1108,7 @@ namespace PreferToHaveLength { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | strict | * ``` @@ -1092,6 +1126,7 @@ namespace PreferEqualityMatcher { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | strict | * ``` @@ -1109,6 +1144,7 @@ namespace PreferStrictEqual { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1126,6 +1162,7 @@ namespace PreferExpectResolves { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1142,6 +1179,7 @@ namespace PreferEach { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1158,6 +1196,7 @@ namespace PreferHooksOnTop { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1174,6 +1213,7 @@ namespace PreferHooksInOrder { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1190,6 +1230,7 @@ namespace RequireLocalTestContextForConcurrentSnapshots { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1207,6 +1248,7 @@ namespace PreferMockPromiseShorthand { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1243,6 +1285,7 @@ namespace PreferSnapshotHint { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1259,6 +1302,7 @@ namespace ValidDescribeCallback { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1300,6 +1344,7 @@ namespace RequireTopLevelDescribe { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1316,6 +1361,7 @@ namespace RequireToThrowMessage { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -1359,6 +1405,7 @@ namespace RequireHook { * | key | value | * | :---------- | :----- | * | type | layout | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1376,6 +1423,7 @@ namespace PreferTodo { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1393,6 +1441,7 @@ namespace PreferSpyOn { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1410,6 +1459,7 @@ namespace PreferComparisonMatcher { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -1427,6 +1477,7 @@ namespace PreferToContain { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | strict | * ``` diff --git a/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts b/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts index b328351f9e..b8e02d0f74 100644 --- a/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts +++ b/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts @@ -17,6 +17,7 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | stylistic | * ``` */ @@ -33,6 +34,7 @@ namespace AdjacentOverloadSignatures { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * ``` @@ -95,6 +97,7 @@ namespace ArrayType { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | recommended | * | requiresTypeChecking | true | @@ -113,6 +116,7 @@ namespace AwaitThenable { * | key | value | * | :------------- | :-------------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | [object Object] | * ``` @@ -208,6 +212,7 @@ namespace BanTsComment { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * ``` @@ -225,6 +230,7 @@ namespace BanTslintComment { * | key | value | * | :------------- | :-------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | stylistic | * ``` @@ -264,6 +270,7 @@ namespace ClassLiteralPropertyStyle { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | requiresTypeChecking | false | * ``` */ @@ -347,6 +354,7 @@ namespace ClassMethodsUseThis { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * ``` @@ -386,6 +394,7 @@ namespace ConsistentGenericConstructors { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | stylistic | @@ -426,6 +435,7 @@ namespace ConsistentIndexedObjectStyle { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | requiresTypeChecking | true | * ``` */ @@ -466,6 +476,7 @@ namespace ConsistentReturn { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | stylistic | @@ -573,6 +584,7 @@ namespace ConsistentTypeAssertions { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * ``` @@ -612,6 +624,7 @@ namespace ConsistentTypeDefinitions { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | requiresTypeChecking | true | * ``` @@ -655,10 +668,11 @@ namespace ConsistentTypeExports { * @link https://typescript-eslint.io/rules/consistent-type-imports * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace ConsistentTypeImports { @@ -720,9 +734,10 @@ namespace ConsistentTypeImports { * @link https://typescript-eslint.io/rules/default-param-last * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace DefaultParamLast { @@ -738,6 +753,7 @@ namespace DefaultParamLast { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * | requiresTypeChecking | true | @@ -817,9 +833,10 @@ namespace DotNotation { * @link https://typescript-eslint.io/rules/explicit-function-return-type * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace ExplicitFunctionReturnType { @@ -921,6 +938,7 @@ namespace ExplicitFunctionReturnType { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * ``` @@ -1033,9 +1051,10 @@ namespace ExplicitMemberAccessibility { * @link https://typescript-eslint.io/rules/explicit-module-boundary-types * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace ExplicitModuleBoundaryTypes { @@ -1115,9 +1134,10 @@ namespace ExplicitModuleBoundaryTypes { * @link https://typescript-eslint.io/rules/init-declarations * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace InitDeclarations { @@ -1183,9 +1203,10 @@ namespace InitDeclarations { * @link https://typescript-eslint.io/rules/max-params * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace MaxParams { @@ -1238,9 +1259,10 @@ namespace MaxParams { * @link https://typescript-eslint.io/rules/member-ordering * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace MemberOrdering { @@ -1798,10 +1820,11 @@ namespace MemberOrdering { * @link https://typescript-eslint.io/rules/method-signature-style * * ```md - * | key | value | - * | :------ | :--------- | - * | type | suggestion | - * | fixable | code | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace MethodSignatureStyle { @@ -1837,6 +1860,7 @@ namespace MethodSignatureStyle { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | requiresTypeChecking | true | * ``` */ @@ -4089,6 +4113,7 @@ namespace NamingConvention { * | key | value | * | :---------- | :---------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | recommended | * ``` @@ -4106,6 +4131,7 @@ namespace NoArrayConstructor { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | recommended | * | requiresTypeChecking | true | @@ -4125,6 +4151,7 @@ namespace NoArrayDelete { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -4171,6 +4198,7 @@ namespace NoBaseToString { * | key | value | * | :------------- | :-------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | stylistic | * ``` @@ -4188,6 +4216,7 @@ namespace NoConfusingNonNullAssertion { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | strict | @@ -4251,6 +4280,7 @@ namespace NoConfusingVoidExpression { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | true | * ``` @@ -4414,9 +4444,10 @@ namespace NoDeprecated { * @link https://typescript-eslint.io/rules/no-dupe-class-members * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoDupeClassMembers { @@ -4432,6 +4463,7 @@ namespace NoDupeClassMembers { * | key | value | * | :------------- | :---------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | false | * | recommended | recommended | * ``` @@ -4449,6 +4481,7 @@ namespace NoDuplicateEnumValues { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | recommended | * | requiresTypeChecking | true | @@ -4499,6 +4532,7 @@ namespace NoDuplicateTypeConstituents { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * ``` @@ -4516,6 +4550,7 @@ namespace NoDynamicDelete { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | stylistic | * ``` */ @@ -4629,6 +4664,7 @@ namespace NoEmptyInterface { * | key | value | * | :------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | recommended | * ``` @@ -4696,6 +4732,7 @@ namespace NoEmptyObjectType { * | key | value | * | :------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | recommended | @@ -4749,6 +4786,7 @@ namespace NoExplicitAny { * | key | value | * | :---------- | :---------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | recommended | * ``` @@ -4766,6 +4804,7 @@ namespace NoExtraNonNullAssertion { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -4826,6 +4865,7 @@ namespace NoExtraneousClass { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | recommended | * | requiresTypeChecking | true | @@ -5140,6 +5180,7 @@ namespace NoFloatingPromises { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -5157,6 +5198,7 @@ namespace NoForInArray { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -5172,10 +5214,11 @@ namespace NoImpliedEval { * @link https://typescript-eslint.io/rules/no-import-type-side-effects * * ```md - * | key | value | - * | :------ | :------ | - * | type | problem | - * | fixable | code | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoImportTypeSideEffects { @@ -5192,6 +5235,7 @@ namespace NoImportTypeSideEffects { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * ``` @@ -5238,9 +5282,10 @@ namespace NoInferrableTypes { * @link https://typescript-eslint.io/rules/no-invalid-this * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoInvalidThis { @@ -5280,6 +5325,7 @@ namespace NoInvalidThis { * | key | value | * | :---------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -5341,9 +5387,10 @@ namespace NoInvalidVoidType { * @link https://typescript-eslint.io/rules/no-loop-func * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoLoopFunc { @@ -5372,9 +5419,10 @@ namespace NoLossOfPrecision { * @link https://typescript-eslint.io/rules/no-magic-numbers * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoMagicNumbers { @@ -5478,6 +5526,7 @@ namespace NoMagicNumbers { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | strict | @@ -5524,6 +5573,7 @@ namespace NoMeaninglessVoidOperator { * | key | value | * | :---------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * ``` */ @@ -5540,6 +5590,7 @@ namespace NoMisusedNew { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -5667,6 +5718,7 @@ namespace NoMisusedPromises { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | true | * ``` @@ -5833,6 +5885,7 @@ namespace NoMisusedSpread { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | true | * ``` @@ -5850,6 +5903,7 @@ namespace NoMixedEnums { * | key | value | * | :---------- | :---------- | * | type | suggestion | + * | deprecated | false | * | recommended | recommended | * ``` */ @@ -5902,6 +5956,7 @@ namespace NoNamespace { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | strict | * ``` @@ -5919,6 +5974,7 @@ namespace NoNonNullAssertedNullishCoalescing { * | key | value | * | :------------- | :---------- | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | recommended | * ``` @@ -5936,6 +5992,7 @@ namespace NoNonNullAssertedOptionalChain { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | strict | * ``` @@ -5950,9 +6007,10 @@ namespace NoNonNullAssertion { * @link https://typescript-eslint.io/rules/no-redeclare * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoRedeclare { @@ -6004,6 +6062,7 @@ namespace NoRedeclare { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -6021,6 +6080,7 @@ namespace NoRedundantTypeConstituents { * | key | value | * | :---------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * ``` */ @@ -6069,9 +6129,10 @@ namespace NoRequireImports { * @link https://typescript-eslint.io/rules/no-restricted-imports * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoRestrictedImports { @@ -6311,6 +6372,7 @@ namespace NoRestrictedImports { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * ``` @@ -6412,9 +6474,10 @@ namespace NoRestrictedTypes { * @link https://typescript-eslint.io/rules/no-shadow * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoShadow { @@ -6507,6 +6570,7 @@ namespace NoShadow { * | key | value | * | :---------- | :---------- | * | type | suggestion | + * | deprecated | false | * | recommended | recommended | * ``` */ @@ -6642,6 +6706,7 @@ namespace NoTypeAlias { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * | requiresTypeChecking | true | @@ -6698,6 +6763,7 @@ namespace NoUnnecessaryBooleanLiteralCompare { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * | requiresTypeChecking | true | @@ -6757,9 +6823,10 @@ namespace NoUnnecessaryCondition { * @link https://typescript-eslint.io/rules/no-unnecessary-parameter-property-assignment * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoUnnecessaryParameterPropertyAssignment { @@ -6775,6 +6842,7 @@ namespace NoUnnecessaryParameterPropertyAssignment { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | requiresTypeChecking | true | * ``` @@ -6792,6 +6860,7 @@ namespace NoUnnecessaryQualifier { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * | requiresTypeChecking | true | @@ -6810,6 +6879,7 @@ namespace NoUnnecessaryTemplateExpression { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * | requiresTypeChecking | true | @@ -6828,6 +6898,7 @@ namespace NoUnnecessaryTypeArguments { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | recommended | * | requiresTypeChecking | true | @@ -6875,6 +6946,7 @@ namespace NoUnnecessaryTypeAssertion { * | key | value | * | :------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | recommended | * ``` @@ -6892,6 +6964,7 @@ namespace NoUnnecessaryTypeConstraint { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | strict | * | requiresTypeChecking | true | @@ -6910,6 +6983,7 @@ namespace NoUnnecessaryTypeParameters { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -6927,6 +7001,7 @@ namespace NoUnsafeArgument { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -6944,6 +7019,7 @@ namespace NoUnsafeAssignment { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -6961,6 +7037,7 @@ namespace NoUnsafeCall { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | false | * ``` @@ -6978,6 +7055,7 @@ namespace NoUnsafeDeclarationMerging { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | recommended | * | requiresTypeChecking | true | @@ -6996,6 +7074,7 @@ namespace NoUnsafeEnumComparison { * | key | value | * | :---------- | :---------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | recommended | * ``` @@ -7013,6 +7092,7 @@ namespace NoUnsafeFunctionType { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -7030,6 +7110,7 @@ namespace NoUnsafeMemberAccess { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -7047,6 +7128,7 @@ namespace NoUnsafeReturn { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | requiresTypeChecking | true | * ``` */ @@ -7063,6 +7145,7 @@ namespace NoUnsafeTypeAssertion { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -7080,6 +7163,7 @@ namespace NoUnsafeUnaryMinus { * | key | value | * | :---------- | :---------- | * | type | suggestion | + * | deprecated | false | * | recommended | recommended | * ``` */ @@ -7132,6 +7216,7 @@ namespace NoUnusedExpressions { * | key | value | * | :---------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * ``` */ @@ -7264,9 +7349,10 @@ namespace NoUnusedVars { * @link https://typescript-eslint.io/rules/no-use-before-define * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoUseBeforeDefine { @@ -7359,6 +7445,7 @@ namespace NoUseBeforeDefine { * | key | value | * | :------------- | :------ | * | type | problem | + * | deprecated | false | * | hasSuggestions | true | * | recommended | strict | * ``` @@ -7376,6 +7463,7 @@ namespace NoUselessConstructor { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | false | * ``` @@ -7430,6 +7518,7 @@ namespace NoVarRequires { * | key | value | * | :---------- | :---------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | recommended | * ``` @@ -7447,6 +7536,7 @@ namespace NoWrapperObjectTypes { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * | requiresTypeChecking | true | @@ -7465,6 +7555,7 @@ namespace NonNullableTypeAssertionStyle { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -7640,9 +7731,10 @@ namespace OnlyThrowError { * @link https://typescript-eslint.io/rules/parameter-properties * * ```md - * | key | value | - * | :--- | :------ | - * | type | problem | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace ParameterProperties { @@ -7720,6 +7812,7 @@ namespace ParameterProperties { * | key | value | * | :------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | recommended | @@ -7738,6 +7831,7 @@ namespace PreferAsConst { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | requiresTypeChecking | true | * ``` @@ -7856,6 +7950,7 @@ namespace PreferDestructuring { * | key | value | * | :------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * ``` */ @@ -7873,6 +7968,7 @@ namespace PreferEnumInitializers { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | stylistic | * | requiresTypeChecking | true | @@ -7891,6 +7987,7 @@ namespace PreferFind { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | stylistic | * ``` */ @@ -7907,6 +8004,7 @@ namespace PreferForOf { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * ``` @@ -7924,6 +8022,7 @@ namespace PreferFunctionType { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * | requiresTypeChecking | true | @@ -7942,6 +8041,7 @@ namespace PreferIncludes { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | false | * ``` @@ -7986,6 +8086,7 @@ namespace PreferLiteralEnumMember { * | key | value | * | :---------- | :---------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | recommended | * ``` @@ -8004,6 +8105,7 @@ namespace PreferNamespaceKeyword { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | stylistic | * | requiresTypeChecking | true | @@ -8134,6 +8236,7 @@ namespace PreferNullishCoalescing { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | stylistic | @@ -8245,6 +8348,7 @@ namespace PreferOptionalChain { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -8301,6 +8405,7 @@ namespace PreferPromiseRejectErrors { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | requiresTypeChecking | true | * ``` @@ -8348,6 +8453,7 @@ namespace PreferReadonly { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | requiresTypeChecking | true | * ``` */ @@ -8532,6 +8638,7 @@ namespace PreferReadonlyParameterTypes { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | fixable | code | * | recommended | strict | * | requiresTypeChecking | true | @@ -8550,6 +8657,7 @@ namespace PreferReduceTypeParameter { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * | requiresTypeChecking | true | @@ -8568,6 +8676,7 @@ namespace PreferRegexpExec { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | strict | * | requiresTypeChecking | true | @@ -8587,6 +8696,7 @@ namespace PreferReturnThisType { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | recommended | stylistic | * | requiresTypeChecking | true | @@ -8655,6 +8765,7 @@ namespace PreferTsExpectError { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | requiresTypeChecking | true | * ``` @@ -8732,6 +8843,7 @@ namespace PromiseFunctionAsync { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | recommended | strict | * | requiresTypeChecking | true | * ``` @@ -8750,6 +8862,7 @@ namespace RelatedGetterSetterPairs { * | key | value | * | :------------------- | :------ | * | type | problem | + * | deprecated | false | * | requiresTypeChecking | true | * ``` */ @@ -8793,6 +8906,7 @@ namespace RequireArraySortCompare { * | key | value | * | :------------------- | :---------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | recommended | recommended | * | requiresTypeChecking | true | @@ -8812,6 +8926,7 @@ namespace RequireAwait { * | key | value | * | :------------------- | :-------------- | * | type | problem | + * | deprecated | false | * | recommended | [object Object] | * | requiresTypeChecking | true | * ``` @@ -8888,6 +9003,7 @@ namespace RestrictPlusOperands { * | key | value | * | :------------------- | :-------------- | * | type | problem | + * | deprecated | false | * | recommended | [object Object] | * | requiresTypeChecking | true | * ``` @@ -9096,6 +9212,7 @@ namespace RestrictTemplateExpressions { * | key | value | * | :------------------- | :-------------- | * | type | problem | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | [object Object] | @@ -9230,6 +9347,7 @@ namespace SortTypeConstituents { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | requiresTypeChecking | true | * ``` @@ -9328,6 +9446,7 @@ namespace StrictBooleanExpressions { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | hasSuggestions | true | * | requiresTypeChecking | true | * ``` @@ -9399,6 +9518,7 @@ namespace SwitchExhaustivenessCheck { * | key | value | * | :---------- | :---------- | * | type | suggestion | + * | deprecated | false | * | recommended | recommended | * ``` */ @@ -9463,9 +9583,10 @@ namespace TripleSlashReference { * @link https://typescript-eslint.io/rules/typedef * * ```md - * | key | value | - * | :--- | :--------- | - * | type | suggestion | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace Typedef { @@ -9567,6 +9688,7 @@ namespace Typedef { * | key | value | * | :------------------- | :---------- | * | type | problem | + * | deprecated | false | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -9611,6 +9733,7 @@ namespace UnboundMethod { * | key | value | * | :---------- | :--------- | * | type | suggestion | + * | deprecated | false | * | recommended | strict | * ``` */ @@ -9656,6 +9779,7 @@ namespace UnifiedSignatures { * | key | value | * | :------------------- | :--------- | * | type | suggestion | + * | deprecated | false | * | fixable | code | * | hasSuggestions | true | * | recommended | strict | diff --git a/packages/strict-ts-lib/source/package.json b/packages/strict-ts-lib/source/package.json index 0814cbcef7..cbac27f5ad 100644 --- a/packages/strict-ts-lib/source/package.json +++ b/packages/strict-ts-lib/source/package.json @@ -44,7 +44,7 @@ "@types/eslint": "9.6.1", "@typescript-eslint/eslint-plugin": "8.21.0", "@typescript-eslint/parser": "8.21.0", - "eslint": "9.18.0", + "eslint": "9.20.1", "eslint-plugin-functional": "7.1.0" }, "wireit": { diff --git a/yarn.lock b/yarn.lock index 750ebef89d..9646559f88 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2258,6 +2258,13 @@ dependencies: "@types/json-schema" "^7.0.15" +"@eslint/core@^0.11.0": + version "0.11.0" + resolved "https://registry.yarnpkg.com/@eslint/core/-/core-0.11.0.tgz#7a9226e850922e42cbd2ba71361eacbe74352a12" + integrity sha512-DWUB2pksgNEb6Bz2fggIy1wh6fGgZP4Xyy/Mt0QZPiloKKXerbqq9D3SBQTlCRYOrcRPu4vuz+CGjwdfqxnoWA== + dependencies: + "@types/json-schema" "^7.0.15" + "@eslint/eslintrc@^3.2.0": version "3.2.0" resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-3.2.0.tgz#57470ac4e2e283a6bf76044d63281196e370542c" @@ -2273,10 +2280,10 @@ minimatch "^3.1.2" strip-json-comments "^3.1.1" -"@eslint/js@9.18.0": - version "9.18.0" - resolved "https://registry.yarnpkg.com/@eslint/js/-/js-9.18.0.tgz#3356f85d18ed3627ab107790b53caf7e1e3d1e84" - integrity sha512-fK6L7rxcq6/z+AaQMtiFTkvbHkBLNlwyRxHpKawP0x3u9+NC6MQTnFW+AdpwC6gfHTW0051cokQgtTN2FqlxQA== +"@eslint/js@9.20.0": + version "9.20.0" + resolved "https://registry.yarnpkg.com/@eslint/js/-/js-9.20.0.tgz#7421bcbe74889fcd65d1be59f00130c289856eb4" + integrity sha512-iZA07H9io9Wn836aVTytRaNqh00Sad+EamwOVJT12GTLw1VGMFV/4JaME+JjLtr9fiGaoWgYnS54wrfWsSs4oQ== "@eslint/object-schema@^2.1.5": version "2.1.5" @@ -8509,17 +8516,17 @@ eslint-visitor-keys@^4.2.0: resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz#687bacb2af884fcdda8a6e7d65c606f46a14cd45" integrity sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw== -eslint@9.18.0: - version "9.18.0" - resolved "https://registry.yarnpkg.com/eslint/-/eslint-9.18.0.tgz#c95b24de1183e865de19f607fda6518b54827850" - integrity sha512-+waTfRWQlSbpt3KWE+CjrPPYnbq9kfZIYUqapc0uBXyjTp8aYXZDsUH16m39Ryq3NjAVP4tjuF7KaukeqoCoaA== +eslint@9.20.1: + version "9.20.1" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-9.20.1.tgz#923924c078f5226832449bac86662dd7e53c91d6" + integrity sha512-m1mM33o6dBUjxl2qb6wv6nGNwCAsns1eKtaQ4l/NPHeTvhiUPbtdfMyktxN4B3fgHIgsYh1VT3V9txblpQHq+g== dependencies: "@eslint-community/eslint-utils" "^4.2.0" "@eslint-community/regexpp" "^4.12.1" "@eslint/config-array" "^0.19.0" - "@eslint/core" "^0.10.0" + "@eslint/core" "^0.11.0" "@eslint/eslintrc" "^3.2.0" - "@eslint/js" "9.18.0" + "@eslint/js" "9.20.0" "@eslint/plugin-kit" "^0.2.5" "@humanfs/node" "^0.16.6" "@humanwhocodes/module-importer" "^1.0.1" From 54a8dbd26ec67746b442aa1647ee3f46735495aa Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sat, 22 Feb 2025 16:38:05 +0900 Subject: [PATCH 21/25] feat: [eslint-configs] add eslint-plugin-react-perf and update packages --- packages/eslint-configs/.gitignore | 1 + packages/eslint-configs/package.json | 17 +- .../eslint-configs/scripts/eslint-plugins.mts | 6 + .../scripts/generate-rules-type-core.mts | 39 ++- .../scripts/generate-rules-type.mts | 4 +- .../scripts/update-dependencies.mts | 58 ++-- .../eslint-configs/src/configs/plugins.mts | 26 +- .../eslint-configs/src/configs/react-base.mts | 2 + .../src/configs/typescript-without-rules.mts | 3 - .../eslint-configs/src/configs/typescript.mts | 3 +- .../rules/unsafe-assignment-rule.mts | 8 +- .../src/plugins/tree-shakable/index.mts | 4 +- .../src/rules/eslint-noshiro-custom.mts | 18 - .../src/rules/eslint-react-perf-rules.mts | 9 + packages/eslint-configs/src/rules/index.mts | 2 +- .../eslint-configs/src/types/flat-config.mts | 8 + .../types/rules/eslint-react-perf-rules.mts | 227 +++++++++++++ .../rules/eslint-total-functions-rules.mts | 108 +++--- .../rules/eslint-tree-shakable-rules.mts | 9 +- .../eslint-configs/src/types/rules/index.mts | 1 + .../types/rules/typescript-eslint-rules.mts | 42 ++- packages/eslint-configs/src/types/types.mts | 4 - packages/strict-ts-lib/source/package.json | 6 +- yarn.lock | 318 ++++++++++-------- 24 files changed, 595 insertions(+), 328 deletions(-) create mode 100644 packages/eslint-configs/.gitignore delete mode 100644 packages/eslint-configs/src/rules/eslint-noshiro-custom.mts create mode 100644 packages/eslint-configs/src/rules/eslint-react-perf-rules.mts create mode 100644 packages/eslint-configs/src/types/rules/eslint-react-perf-rules.mts diff --git a/packages/eslint-configs/.gitignore b/packages/eslint-configs/.gitignore new file mode 100644 index 0000000000..5c11fb2e43 --- /dev/null +++ b/packages/eslint-configs/.gitignore @@ -0,0 +1 @@ +src/**/*.mjs diff --git a/packages/eslint-configs/package.json b/packages/eslint-configs/package.json index f6edda9afe..9dc9a50c6a 100644 --- a/packages/eslint-configs/package.json +++ b/packages/eslint-configs/package.json @@ -53,12 +53,12 @@ }, "dependencies": { "@types/eslint": "9.6.1", - "@typescript-eslint/eslint-plugin": "8.21.0", - "@typescript-eslint/parser": "8.21.0", + "@typescript-eslint/eslint-plugin": "8.24.1", + "@typescript-eslint/parser": "8.24.1", "@typescript-eslint/type-utils": "8.21.0", - "@typescript-eslint/utils": "8.21.0", - "eslint": "9.20.1", - "eslint-import-resolver-typescript": "3.7.0", + "@typescript-eslint/utils": "8.24.1", + "eslint": "9.21.0", + "eslint-import-resolver-typescript": "3.8.3", "eslint-plugin-array-func": "5.0.2", "eslint-plugin-cypress": "4.1.0", "eslint-plugin-eslint-plugin": "6.4.0", @@ -71,18 +71,17 @@ "eslint-plugin-promise": "7.2.1", "eslint-plugin-react": "7.37.4", "eslint-plugin-react-hooks": "5.1.0", + "eslint-plugin-react-perf": "3.3.3", "eslint-plugin-react-refresh": "0.4.18", "eslint-plugin-security": "3.0.1", "eslint-plugin-strict-dependencies": "1.3.15", "eslint-plugin-testing-library": "7.1.1", - "eslint-plugin-total-functions": "7.1.0", - "eslint-plugin-tree-shakable": "1.2.0", "eslint-plugin-unicorn": "56.0.1", "eslint-plugin-vitest": "0.5.4", - "globals": "15.14.0", + "globals": "16.0.0", "is-immutable-type": "1.2.9", "tsutils": "3.21.0", - "typescript-eslint": "8.21.0" + "typescript-eslint": "8.24.1" }, "devDependencies": { "@noshiro/mono-utils": "*", diff --git a/packages/eslint-configs/scripts/eslint-plugins.mts b/packages/eslint-configs/scripts/eslint-plugins.mts index 09f44ec65b..e84b5cdd8e 100644 --- a/packages/eslint-configs/scripts/eslint-plugins.mts +++ b/packages/eslint-configs/scripts/eslint-plugins.mts @@ -95,6 +95,12 @@ export const eslintPlugins = { rulePrefix: 'react-refresh/', outputFileName: 'eslint-react-refresh-rules.mts', }, + EslintReactPerf: { + typeName: 'EslintReactPerfRules', + pluginName: 'eslint-plugin-react-perf', + rulePrefix: 'react-perf/', + outputFileName: 'eslint-react-perf-rules.mts', + }, EslintJsxA11y: { typeName: 'EslintJsxA11yRules', pluginName: 'eslint-plugin-jsx-a11y', diff --git a/packages/eslint-configs/scripts/generate-rules-type-core.mts b/packages/eslint-configs/scripts/generate-rules-type-core.mts index 24ba19b688..cce04748fd 100644 --- a/packages/eslint-configs/scripts/generate-rules-type-core.mts +++ b/packages/eslint-configs/scripts/generate-rules-type-core.mts @@ -1,9 +1,14 @@ import { type DeprecatedInfo } from '@eslint/core'; import { toSafeUint, toUint32 } from '@noshiro/mono-utils'; -import { type Rule } from 'eslint'; import { builtinRules } from 'eslint/use-at-your-own-risk'; import { type JSONSchema4 } from 'json-schema'; import { compile, type Options } from 'json-schema-to-typescript'; +import { type Rule, type Rules } from '../src/index.mjs'; +import { + eslintPluginTotalFunctions, + eslintPluginTreeShakable, +} from '../src/plugins/index.mjs'; +import { eslintPlugins } from './eslint-plugins.mjs'; import { deepCopy, deepReplace, @@ -46,7 +51,7 @@ const normalizeToSchemaArray = ( const removeMultiLineCommentCharacter = (str: string): string => str.replace('/*', ' ').replace('*/', ' '); -const metaToString = (meta: DeepReadonly): string => { +const metaToString = (meta: DeepReadonly): string => { if (meta === undefined) return ''; const { deprecated, docs, fixable, hasSuggestions, type } = meta; @@ -328,17 +333,27 @@ export const generateRulesTypeCore = async ( pluginName: string, rulePrefixOrNull: string | undefined, ): Promise => { - // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, import/dynamic-import-chunkname - const pluginPackage = await import(pluginName); - - const rules: DeepReadonly<[string, Rule.RuleModule][]> = + const rules: DeepReadonly<[string, Rule][]> = pluginName === 'eslint' - ? // eslint-disable-next-line @typescript-eslint/no-deprecated - deepCopy(Array.from(builtinRules.entries())) - : Object.entries( - // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-member-access - pluginPackage.default.rules as Record, - ); + ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion + (deepCopy( + // eslint-disable-next-line @typescript-eslint/no-deprecated + Array.from(builtinRules.entries()), + ) as unknown as DeepReadonly<[string, Rule][]>) + : pluginName === eslintPlugins.EslintTotalFunctions.pluginName + ? (Object.entries( + // eslint-disable-next-line total-functions/no-unsafe-type-assertion + eslintPluginTotalFunctions.rules as Rules, + ) satisfies DeepReadonly<[string, Rule][]>) + : pluginName === eslintPlugins.EslintTreeShakable.pluginName + ? (Object.entries( + // eslint-disable-next-line total-functions/no-unsafe-type-assertion + eslintPluginTreeShakable.rules as Rules, + ) satisfies DeepReadonly<[string, Rule][]>) + : (Object.entries( + // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-member-access, import/dynamic-import-chunkname, unicorn/no-await-expression-member + (await import(pluginName)).default.rules as Rules, + ) satisfies DeepReadonly<[string, Rule][]>); const schemaList: DeepReadonly< { diff --git a/packages/eslint-configs/scripts/generate-rules-type.mts b/packages/eslint-configs/scripts/generate-rules-type.mts index 66b3f2d99d..afa9c86075 100644 --- a/packages/eslint-configs/scripts/generate-rules-type.mts +++ b/packages/eslint-configs/scripts/generate-rules-type.mts @@ -112,7 +112,7 @@ const lintFix = async (): Promise< > => { const targetFiles: readonly string[] = await glob(`${outDir}/*.mts`); - const result = await $`ESLINT_USE_FLAT_CONFIG=true yarn eslint ${[ + const result = await $`TIMING=1 eslint ${[ '--no-ignore', '--fix', '--config', @@ -129,7 +129,7 @@ const lintFix = async (): Promise< const prettier = async (): Promise< Readonly<{ type: 'error'; error: unknown } | { type: 'ok' }> > => { - const result = await $`yarn prettier ${[ + const result = await $`prettier ${[ // '--cache --cache-strategy content', `--config`, prettierrcPath, diff --git a/packages/eslint-configs/scripts/update-dependencies.mts b/packages/eslint-configs/scripts/update-dependencies.mts index bb3c796287..54a32c4b52 100644 --- a/packages/eslint-configs/scripts/update-dependencies.mts +++ b/packages/eslint-configs/scripts/update-dependencies.mts @@ -40,40 +40,48 @@ const rewritePackageVersion = async ( await fs.writeFile(packageJsonPath, JSON.stringify(parsed)); }; +const getEslintPluginNames = async ( + packageJsonPath: string | undefined, +): Promise => { + if (packageJsonPath === undefined) return []; + + const content = await fs.readFile(packageJsonPath, { encoding: 'utf8' }); + + const parsed = JSON.parse(content) ?? {}; + + if (!isRecord(parsed)) return []; + + if (!Object.hasOwn(parsed, 'dependencies')) return []; + + const mut_targetPath = castMutable(parsed.dependencies); + + if (!isRecord(mut_targetPath)) return []; + + return Object.keys(mut_targetPath) + .map((key) => mut_targetPath[key]) + .filter( + (s): s is string => + typeof s === 'string' && + (s.startsWith('eslint-plugin-') || s.startsWith('@typescript-eslint')), + ); +}; + const main = async (): Promise => { cd(eslintDir); { echo`${eslintDir}: updating dependencies`; - /** @type {readonly string[]} */ - const packages = [ - '@typescript-eslint/eslint-plugin', - '@typescript-eslint/parser', - '@typescript-eslint/utils', + const pluginNames = await getEslintPluginNames(`${eslintDir}/package.json`); + + const packages: readonly string[] = [ + ...pluginNames, 'eslint-import-resolver-typescript', - 'eslint-plugin-array-func', - 'eslint-plugin-eslint-plugin', - 'eslint-plugin-import', - 'eslint-plugin-jest', - 'eslint-plugin-jsx-a11y', - 'eslint-plugin-prefer-arrow-functions', - 'eslint-plugin-promise', - 'eslint-plugin-react-hooks', - 'eslint-plugin-react-refresh', - 'eslint-plugin-react', - 'eslint-plugin-security', - 'eslint-plugin-strict-dependencies', - 'eslint-plugin-testing-library', - 'eslint-plugin-total-functions', - 'eslint-plugin-tree-shakable', - 'eslint-plugin-unicorn', - 'eslint-plugin-vitest', '@types/eslint', 'globals', 'eslint-plugin-playwright', 'typescript-eslint', 'eslint', - ]; + ] as const; await $`yarn add ${packages.map((a) => `${a}@latest`)}`; @@ -85,7 +93,7 @@ const main = async (): Promise => { cd(monoRootDir); echo`yarn install`; - await $`yarn`; + await $`yarn install`; cd(eslintDir); @@ -111,7 +119,7 @@ const main = async (): Promise => { cd(monoRootDir); - await $`yarn`; + await $`yarn install`; await $`yarn fmt:diff`; }; diff --git a/packages/eslint-configs/src/configs/plugins.mts b/packages/eslint-configs/src/configs/plugins.mts index 68664abc48..3c4576942d 100644 --- a/packages/eslint-configs/src/configs/plugins.mts +++ b/packages/eslint-configs/src/configs/plugins.mts @@ -39,6 +39,9 @@ import eslintPluginReactHooks from 'eslint-plugin-react-hooks'; import eslintPluginReactRefresh from 'eslint-plugin-react-refresh'; +// @ts-expect-error no type definition +import eslintPluginReactPerf from 'eslint-plugin-react-perf'; + // @ts-expect-error no type definition import eslintPluginJsxA11y from 'eslint-plugin-jsx-a11y'; @@ -68,6 +71,7 @@ export const plugins: Record< | 'react' | 'react-hooks' | 'react-refresh' + | 'react-perf' | 'security' | 'strict-dependencies' | 'testing-library' @@ -99,6 +103,7 @@ export const plugins: Record< 'react-hooks': eslintPluginReactHooks, // eslint-disable-next-line total-functions/no-unsafe-type-assertion 'react-refresh': eslintPluginReactRefresh as unknown as Plugin, + 'react-perf': eslintPluginReactPerf, // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment security: eslintPluginSecurity, // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment @@ -110,24 +115,3 @@ export const plugins: Record< // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment 'eslint-plugin': eslintPluginEslintPlugin, } as const satisfies FlatConfig['plugins']; - -// export const pluginsV9Supported = { -// '@typescript-eslint': true, -// 'array-func': true, -// cypress: true, -// functional: true, -// import: false, -// jest: true, -// vitest: true, -// 'jsx-a11y': true, -// 'prefer-arrow-functions': true, -// promise: false, -// react: false, -// 'react-hooks': true, -// 'react-refresh': true, -// security: true, -// 'strict-dependencies': true, -// 'testing-library': true, -// 'total-functions': false, -// unicorn: true, -// } as const satisfies { [key in keyof typeof pluginsDef]: boolean }; diff --git a/packages/eslint-configs/src/configs/react-base.mts b/packages/eslint-configs/src/configs/react-base.mts index a260ed6113..30181c6e14 100644 --- a/packages/eslint-configs/src/configs/react-base.mts +++ b/packages/eslint-configs/src/configs/react-base.mts @@ -2,6 +2,7 @@ import globals from 'globals'; import { eslintJsxA11yRules, eslintReactHooksRules, + eslintReactPerfRules, eslintReactRefreshRules, eslintReactRules, restrictedGlobalsForFrontend, @@ -30,6 +31,7 @@ export const eslintFlatConfigForReactBase = ( ...eslintReactHooksRules, ...eslintReactRefreshRules, ...eslintJsxA11yRules, + ...eslintReactPerfRules, 'no-restricted-globals': [ 'error', diff --git a/packages/eslint-configs/src/configs/typescript-without-rules.mts b/packages/eslint-configs/src/configs/typescript-without-rules.mts index dc6b1d0afa..d0cee164cf 100644 --- a/packages/eslint-configs/src/configs/typescript-without-rules.mts +++ b/packages/eslint-configs/src/configs/typescript-without-rules.mts @@ -6,18 +6,15 @@ import { plugins } from './plugins.mjs'; export const eslintFlatConfigForTypeScriptWithoutRules = ({ tsconfigFileName, tsconfigRootDir, - files, }: Readonly<{ tsconfigFileName: string; tsconfigRootDir: string; - files?: readonly string[]; }>): readonly FlatConfig[] => [ { ignores: ['eslint.config.js', 'eslint.config.*.mjs'], }, { - ...(files === undefined ? {} : { files }), languageOptions: { ecmaVersion: 'latest', parser: typescriptEslintParser, diff --git a/packages/eslint-configs/src/configs/typescript.mts b/packages/eslint-configs/src/configs/typescript.mts index 265e359bc3..b177475af0 100644 --- a/packages/eslint-configs/src/configs/typescript.mts +++ b/packages/eslint-configs/src/configs/typescript.mts @@ -27,10 +27,9 @@ export const eslintFlatConfigForTypeScript = ({ ...eslintFlatConfigForTypeScriptWithoutRules({ tsconfigFileName, tsconfigRootDir, - files, }), { - files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'], + files: files ?? ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'], rules: { ...eslintArrayFuncRules, ...eslintFunctionalRules, diff --git a/packages/eslint-configs/src/plugins/total-functions/rules/unsafe-assignment-rule.mts b/packages/eslint-configs/src/plugins/total-functions/rules/unsafe-assignment-rule.mts index 6221263648..e4ecfa1e1e 100644 --- a/packages/eslint-configs/src/plugins/total-functions/rules/unsafe-assignment-rule.mts +++ b/packages/eslint-configs/src/plugins/total-functions/rules/unsafe-assignment-rule.mts @@ -28,7 +28,7 @@ export const createNoUnsafeAssignmentRule = // we know are shallow copies and therefore safe to have their result // assigned to a readonly array. const isSafeAssignmentFromArrayMethod = ( - sourceExpression: TSESTree.Expression, + sourceExpression: TSESTree.Expression | undefined, destinationType: Type, sourceType: Type, ): 'safe' | 'unsafe' | 'unknown' => { @@ -50,7 +50,7 @@ export const createNoUnsafeAssignmentRule = destinationIndexType !== undefined && sourceIndexType !== undefined && // and the assignment is from calling a member (obj.method(...)) - sourceExpression.type === AST_NODE_TYPES.CallExpression && + sourceExpression?.type === AST_NODE_TYPES.CallExpression && sourceExpression.callee.type === AST_NODE_TYPES.MemberExpression && // and the thing being called is an array // (so we can avoid permitting calls to array methods on other types) @@ -257,7 +257,7 @@ export const createNoUnsafeAssignmentRule = const sourceType = checker.getTypeAtLocation(tsNode.expression); const arrayMethodCallSafety = isSafeAssignmentFromArrayMethod( - node.argument, + node.argument ?? undefined, destinationType, sourceType, ); @@ -272,7 +272,7 @@ export const createNoUnsafeAssignmentRule = checker, destinationType, sourceType, - node.argument, + node.argument ?? undefined, ) === 'unsafe' ) { context.report({ diff --git a/packages/eslint-configs/src/plugins/tree-shakable/index.mts b/packages/eslint-configs/src/plugins/tree-shakable/index.mts index 1de426a5a4..a1d116e61a 100644 --- a/packages/eslint-configs/src/plugins/tree-shakable/index.mts +++ b/packages/eslint-configs/src/plugins/tree-shakable/index.mts @@ -3,4 +3,6 @@ import { rules } from './rules/index.mjs'; // forked from https://github.com/uhyo/eslint-plugin-tree-shakable/releases/tag/v1.2.0 -export const eslintPluginTreeShakable: Omit = { rules }; +export const eslintPluginTreeShakable: Omit = { + rules, +} as const; diff --git a/packages/eslint-configs/src/rules/eslint-noshiro-custom.mts b/packages/eslint-configs/src/rules/eslint-noshiro-custom.mts deleted file mode 100644 index 67c095d2e5..0000000000 --- a/packages/eslint-configs/src/rules/eslint-noshiro-custom.mts +++ /dev/null @@ -1,18 +0,0 @@ -import { type LinterRulesRecord } from '../types/types.mjs'; - -export const eslintNoshiroCustomRules: LinterRulesRecord = { - '@typescript-eslint/prefer-readonly-parameter-types': 'off', - 'noshiro-custom/prefer-readonly-parameter-types': [ - 'warn', - { - checkParameterProperties: true, - ignoreInferredTypes: true, - allow: [ - 'ServiceWorkerRegistration', - 'Observable', - 'Iterator', - 'Iterable', - ], - }, - ], -} as const; diff --git a/packages/eslint-configs/src/rules/eslint-react-perf-rules.mts b/packages/eslint-configs/src/rules/eslint-react-perf-rules.mts new file mode 100644 index 0000000000..f1f7523513 --- /dev/null +++ b/packages/eslint-configs/src/rules/eslint-react-perf-rules.mts @@ -0,0 +1,9 @@ +import { type EslintReactPerfRules } from '../types/index.mjs'; +import { withDefaultOption } from '../types/rule-severity-branded.mjs'; + +export const eslintReactPerfRules: EslintReactPerfRules = { + 'react-perf/jsx-no-jsx-as-prop': withDefaultOption('error'), + 'react-perf/jsx-no-new-array-as-prop': withDefaultOption('error'), + 'react-perf/jsx-no-new-function-as-prop': withDefaultOption('error'), + 'react-perf/jsx-no-new-object-as-prop': withDefaultOption('error'), +} as const; diff --git a/packages/eslint-configs/src/rules/index.mts b/packages/eslint-configs/src/rules/index.mts index 8f98eee876..36c0c6f3f7 100644 --- a/packages/eslint-configs/src/rules/index.mts +++ b/packages/eslint-configs/src/rules/index.mts @@ -4,12 +4,12 @@ export * from './eslint-functional-rules.mjs'; export * from './eslint-import-rules.mjs'; export * from './eslint-jest-rules.mjs'; export * from './eslint-jsx-a11y-rules.mjs'; -export * from './eslint-noshiro-custom.mjs'; export * from './eslint-playwright-rules.mjs'; export * from './eslint-plugin-rules.mjs'; export * from './eslint-prefer-arrow-functions-rules.mjs'; export * from './eslint-promise-rules.mjs'; export * from './eslint-react-hooks-rules.mjs'; +export * from './eslint-react-perf-rules.mjs'; export * from './eslint-react-refresh-rules.mjs'; export * from './eslint-react-rules.mjs'; export * from './eslint-rules.mjs'; diff --git a/packages/eslint-configs/src/types/flat-config.mts b/packages/eslint-configs/src/types/flat-config.mts index 326c446ade..729220cb96 100644 --- a/packages/eslint-configs/src/types/flat-config.mts +++ b/packages/eslint-configs/src/types/flat-config.mts @@ -1,5 +1,13 @@ +import { type RuleDefinition } from '@eslint/core'; import { type FlatConfig as FlatConfig_ } from '@typescript-eslint/utils/ts-eslint'; export type FlatConfig = DeepReadonly; +// export type Plugin = DeepReadonly; export type Plugin = DeepReadonly; + +export type Rule = DeepReadonly; +// Exclude; + +// export type Rules = DeepReadonly; +export type Rules = Record; diff --git a/packages/eslint-configs/src/types/rules/eslint-react-perf-rules.mts b/packages/eslint-configs/src/types/rules/eslint-react-perf-rules.mts new file mode 100644 index 0000000000..9aaab93c87 --- /dev/null +++ b/packages/eslint-configs/src/types/rules/eslint-react-perf-rules.mts @@ -0,0 +1,227 @@ +/* cSpell:disable */ +import { type Linter } from 'eslint'; +import { type RuleSeverityWithDefaultOption } from '../rule-severity-branded.mjs'; + +type SpreadOptionsIfIsArray< + T extends readonly [Linter.StringSeverity, unknown], +> = T[1] extends readonly unknown[] + ? readonly [Linter.StringSeverity, ...T[1]] + : T; + +/** + * Prevent {...} as JSX prop value + * + * ```md + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | category | | + * | recommended | true | + * ``` + */ +namespace JsxNoNewObjectAsProp { + /** + * ### schema + * + * ```json + * [ + * { + * "additionalProperties": false, + * "properties": { + * "nativeAllowList": { + * "oneOf": [ + * { + * "enum": [ + * "all" + * ] + * }, + * { + * "type": "array", + * "items": { + * "type": "string" + * } + * } + * ] + * } + * }, + * "type": "object" + * } + * ] + * ``` + */ + export type Options = { + readonly nativeAllowList?: readonly string[] | 'all'; + }; + + export type RuleEntry = + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; +} + +/** + * Prevent [...] as JSX prop value + * + * ```md + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | category | | + * | recommended | true | + * ``` + */ +namespace JsxNoNewArrayAsProp { + /** + * ### schema + * + * ```json + * [ + * { + * "additionalProperties": false, + * "properties": { + * "nativeAllowList": { + * "oneOf": [ + * { + * "enum": [ + * "all" + * ] + * }, + * { + * "type": "array", + * "items": { + * "type": "string" + * } + * } + * ] + * } + * }, + * "type": "object" + * } + * ] + * ``` + */ + export type Options = { + readonly nativeAllowList?: readonly string[] | 'all'; + }; + + export type RuleEntry = + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; +} + +/** + * Prevent `function` as JSX prop value + * + * ```md + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | category | | + * | recommended | true | + * ``` + */ +namespace JsxNoNewFunctionAsProp { + /** + * ### schema + * + * ```json + * [ + * { + * "additionalProperties": false, + * "properties": { + * "nativeAllowList": { + * "oneOf": [ + * { + * "enum": [ + * "all" + * ] + * }, + * { + * "type": "array", + * "items": { + * "type": "string" + * } + * } + * ] + * } + * }, + * "type": "object" + * } + * ] + * ``` + */ + export type Options = { + readonly nativeAllowList?: readonly string[] | 'all'; + }; + + export type RuleEntry = + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; +} + +/** + * Prevent JSX as JSX prop value + * + * ```md + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | category | | + * | recommended | true | + * ``` + */ +namespace JsxNoJsxAsProp { + /** + * ### schema + * + * ```json + * [ + * { + * "additionalProperties": false, + * "properties": { + * "nativeAllowList": { + * "oneOf": [ + * { + * "enum": [ + * "all" + * ] + * }, + * { + * "type": "array", + * "items": { + * "type": "string" + * } + * } + * ] + * } + * }, + * "type": "object" + * } + * ] + * ``` + */ + export type Options = { + readonly nativeAllowList?: readonly string[] | 'all'; + }; + + export type RuleEntry = + | RuleSeverityWithDefaultOption + | SpreadOptionsIfIsArray + | 'off'; +} + +export type EslintReactPerfRules = { + readonly 'react-perf/jsx-no-new-object-as-prop': JsxNoNewObjectAsProp.RuleEntry; + readonly 'react-perf/jsx-no-new-array-as-prop': JsxNoNewArrayAsProp.RuleEntry; + readonly 'react-perf/jsx-no-new-function-as-prop': JsxNoNewFunctionAsProp.RuleEntry; + readonly 'react-perf/jsx-no-jsx-as-prop': JsxNoJsxAsProp.RuleEntry; +}; + +export type EslintReactPerfRulesOption = { + readonly 'react-perf/jsx-no-new-object-as-prop': JsxNoNewObjectAsProp.Options; + readonly 'react-perf/jsx-no-new-array-as-prop': JsxNoNewArrayAsProp.Options; + readonly 'react-perf/jsx-no-new-function-as-prop': JsxNoNewFunctionAsProp.Options; + readonly 'react-perf/jsx-no-jsx-as-prop': JsxNoJsxAsProp.Options; +}; diff --git a/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts b/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts index 6d7ebd4ada..dc99a5d8eb 100644 --- a/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-total-functions-rules.mts @@ -7,11 +7,10 @@ import { type Linter } from 'eslint'; * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace RequireStrictMode { @@ -24,11 +23,10 @@ namespace RequireStrictMode { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoUnsafeTypeAssertion { @@ -41,11 +39,10 @@ namespace NoUnsafeTypeAssertion { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoUnsafeReadonlyMutableAssignment { @@ -58,11 +55,10 @@ namespace NoUnsafeReadonlyMutableAssignment { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoUnsafeMutableReadonlyAssignment { @@ -75,11 +71,10 @@ namespace NoUnsafeMutableReadonlyAssignment { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoEnums { @@ -92,11 +87,10 @@ namespace NoEnums { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoPartialUrlConstructor { @@ -109,11 +103,10 @@ namespace NoPartialUrlConstructor { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoPartialDivision { @@ -126,11 +119,10 @@ namespace NoPartialDivision { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoPartialStringNormalize { @@ -143,11 +135,10 @@ namespace NoPartialStringNormalize { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoPrematureFpTsEffects { @@ -160,11 +151,10 @@ namespace NoPrematureFpTsEffects { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoNestedFpTsEffects { @@ -177,11 +167,10 @@ namespace NoNestedFpTsEffects { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoPartialArrayReduce { @@ -194,11 +183,10 @@ namespace NoPartialArrayReduce { * @link https://github.com/danielnixon/eslint-plugin-total-functions * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoHiddenTypeAssertions { diff --git a/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts b/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts index 42c8cee243..ff5a8048f2 100644 --- a/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-tree-shakable-rules.mts @@ -5,11 +5,10 @@ import { type Linter } from 'eslint'; * Forbits non-tree-shakable access to module name space objects. * * ```md - * | key | value | - * | :---------- | :------ | - * | type | problem | - * | deprecated | false | - * | recommended | error | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace ImportStar { diff --git a/packages/eslint-configs/src/types/rules/index.mts b/packages/eslint-configs/src/types/rules/index.mts index 8e2199cc49..7b505cd2ff 100644 --- a/packages/eslint-configs/src/types/rules/index.mts +++ b/packages/eslint-configs/src/types/rules/index.mts @@ -9,6 +9,7 @@ export * from './eslint-plugin-rules.mjs'; export * from './eslint-prefer-arrow-functions-rules.mjs'; export * from './eslint-promise-rules.mjs'; export * from './eslint-react-hooks-rules.mjs'; +export * from './eslint-react-perf-rules.mjs'; export * from './eslint-react-refresh-rules.mjs'; export * from './eslint-react-rules.mjs'; export * from './eslint-rules.mjs'; diff --git a/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts b/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts index b8e02d0f74..7c30cdb757 100644 --- a/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts +++ b/packages/eslint-configs/src/types/rules/typescript-eslint-rules.mts @@ -297,7 +297,7 @@ namespace ClassMethodsUseThis { * } * }, * "ignoreClassesThatImplementAnInterface": { - * "description": "Makes the rule ignore class members that are defined within a class that `implements` a type", + * "description": "Whether to ignore class members that are defined within a class that `implements` a type.", * "oneOf": [ * { * "type": "boolean", @@ -314,7 +314,7 @@ namespace ClassMethodsUseThis { * }, * "ignoreOverrideMethods": { * "type": "boolean", - * "description": "Ignore members marked with the `override` modifier" + * "description": "Whether to ignore members marked with the `override` modifier." * } * } * } @@ -330,11 +330,11 @@ namespace ClassMethodsUseThis { /** Allows specified method names to be ignored with this rule. */ readonly exceptMethods?: readonly string[]; /** - * Makes the rule ignore class members that are defined within a class that - * `implements` a type + * Whether to ignore class members that are defined within a class that + * `implements` a type. */ readonly ignoreClassesThatImplementAnInterface?: boolean | 'public-fields'; - /** Ignore members marked with the `override` modifier */ + /** Whether to ignore members marked with the `override` modifier. */ readonly ignoreOverrideMethods?: boolean; }; @@ -5190,7 +5190,7 @@ namespace NoForInArray { } /** - * Disallow the use of `eval()`-like methods + * Disallow the use of `eval()`-like functions * * @link https://typescript-eslint.io/rules/no-implied-eval * @@ -6729,6 +6729,10 @@ namespace NoUnnecessaryBooleanLiteralCompare { * "allowComparingNullableBooleansToTrue": { * "type": "boolean", * "description": "Whether to allow comparisons between nullable boolean variables and `true`." + * }, + * "allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing": { + * "type": "boolean", + * "description": "Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`." * } * } * } @@ -6746,6 +6750,12 @@ namespace NoUnnecessaryBooleanLiteralCompare { * `true`. */ readonly allowComparingNullableBooleansToTrue?: boolean; + /** + * Unless this is set to `true`, the rule will error on every file whose + * `tsconfig.json` does _not_ have the `strictNullChecks` compiler option + * (or `strict`) set to `true`. + */ + readonly allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean; }; export type RuleEntry = @@ -6780,8 +6790,20 @@ namespace NoUnnecessaryCondition { * "additionalProperties": false, * "properties": { * "allowConstantLoopConditions": { - * "type": "boolean", - * "description": "Whether to ignore constant loop conditions, such as `while (true)`." + * "description": "Whether to ignore constant loop conditions, such as `while (true)`.", + * "oneOf": [ + * { + * "type": "boolean" + * }, + * { + * "type": "string", + * "enum": [ + * "always", + * "never", + * "only-allowed-literals" + * ] + * } + * ] * }, * "allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing": { * "type": "boolean", @@ -6798,7 +6820,9 @@ namespace NoUnnecessaryCondition { */ export type Options = { /** Whether to ignore constant loop conditions, such as `while (true)`. */ - readonly allowConstantLoopConditions?: boolean; + readonly allowConstantLoopConditions?: + | boolean + | ('always' | 'never' | 'only-allowed-literals'); /** * Whether to not error when running with a tsconfig that has * strictNullChecks turned. diff --git a/packages/eslint-configs/src/types/types.mts b/packages/eslint-configs/src/types/types.mts index f77df5c5ba..f0361e92f5 100644 --- a/packages/eslint-configs/src/types/types.mts +++ b/packages/eslint-configs/src/types/types.mts @@ -1,7 +1,3 @@ -import { type Linter } from 'eslint'; - -export type LinterRulesRecord = Readonly>; - export type RestrictedImportsOption = DeepReadonly<{ paths: { name: string; diff --git a/packages/strict-ts-lib/source/package.json b/packages/strict-ts-lib/source/package.json index cbac27f5ad..6c90c32ddd 100644 --- a/packages/strict-ts-lib/source/package.json +++ b/packages/strict-ts-lib/source/package.json @@ -42,9 +42,9 @@ "@noshiro/mono-utils": "*", "@noshiro/ts-type-utils": "*", "@types/eslint": "9.6.1", - "@typescript-eslint/eslint-plugin": "8.21.0", - "@typescript-eslint/parser": "8.21.0", - "eslint": "9.20.1", + "@typescript-eslint/eslint-plugin": "8.24.1", + "@typescript-eslint/parser": "8.24.1", + "eslint": "9.21.0", "eslint-plugin-functional": "7.1.0" }, "wireit": { diff --git a/yarn.lock b/yarn.lock index 9646559f88..ca26767a77 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2237,38 +2237,31 @@ resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.10.0.tgz#548f6de556857c8bb73bbee70c35dc82a2e74d63" integrity sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA== -"@eslint-community/regexpp@^4.12.1", "@eslint-community/regexpp@^4.4.0": +"@eslint-community/regexpp@^4.12.1": version "4.12.1" resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.12.1.tgz#cfc6cffe39df390a3841cde2abccf92eaa7ae0e0" integrity sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ== -"@eslint/config-array@^0.19.0": - version "0.19.1" - resolved "https://registry.yarnpkg.com/@eslint/config-array/-/config-array-0.19.1.tgz#734aaea2c40be22bbb1f2a9dac687c57a6a4c984" - integrity sha512-fo6Mtm5mWyKjA/Chy1BYTdn5mGJoDNjC7C64ug20ADsRDGrA85bN3uK3MaKbeRkRuuIEAR5N33Jr1pbm411/PA== +"@eslint/config-array@^0.19.2": + version "0.19.2" + resolved "https://registry.yarnpkg.com/@eslint/config-array/-/config-array-0.19.2.tgz#3060b809e111abfc97adb0bb1172778b90cb46aa" + integrity sha512-GNKqxfHG2ySmJOBSHg7LxeUx4xpuCoFjacmlCoYWEbaPXLwvfIjixRI12xCQZeULksQb23uiA8F40w5TojpV7w== dependencies: - "@eslint/object-schema" "^2.1.5" + "@eslint/object-schema" "^2.1.6" debug "^4.3.1" minimatch "^3.1.2" -"@eslint/core@^0.10.0": - version "0.10.0" - resolved "https://registry.yarnpkg.com/@eslint/core/-/core-0.10.0.tgz#23727063c21b335f752dbb3a16450f6f9cbc9091" - integrity sha512-gFHJ+xBOo4G3WRlR1e/3G8A6/KZAH6zcE/hkLRCZTi/B9avAG365QhFA8uOGzTMqgTghpn7/fSnscW++dpMSAw== - dependencies: - "@types/json-schema" "^7.0.15" - -"@eslint/core@^0.11.0": - version "0.11.0" - resolved "https://registry.yarnpkg.com/@eslint/core/-/core-0.11.0.tgz#7a9226e850922e42cbd2ba71361eacbe74352a12" - integrity sha512-DWUB2pksgNEb6Bz2fggIy1wh6fGgZP4Xyy/Mt0QZPiloKKXerbqq9D3SBQTlCRYOrcRPu4vuz+CGjwdfqxnoWA== +"@eslint/core@^0.12.0": + version "0.12.0" + resolved "https://registry.yarnpkg.com/@eslint/core/-/core-0.12.0.tgz#5f960c3d57728be9f6c65bd84aa6aa613078798e" + integrity sha512-cmrR6pytBuSMTaBweKoGMwu3EiHiEC+DoyupPmlZ0HxBJBtIxwe+j/E4XPIKNx+Q74c8lXKPwYawBf5glsTkHg== dependencies: "@types/json-schema" "^7.0.15" -"@eslint/eslintrc@^3.2.0": - version "3.2.0" - resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-3.2.0.tgz#57470ac4e2e283a6bf76044d63281196e370542c" - integrity sha512-grOjVNN8P3hjJn/eIETF1wwd12DdnwFDoyceUJLYYdkpbwq3nLi+4fqrTAONx7XDALqlL220wC/RHSC/QTI/0w== +"@eslint/eslintrc@^3.3.0": + version "3.3.0" + resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-3.3.0.tgz#96a558f45842989cca7ea1ecd785ad5491193846" + integrity sha512-yaVPAiNAalnCZedKLdR21GOGILMLKPyqSLWaAjQFvYA2i/ciDi8ArYVr69Anohb6cH2Ukhqti4aFnYyPm8wdwQ== dependencies: ajv "^6.12.4" debug "^4.3.2" @@ -2280,22 +2273,22 @@ minimatch "^3.1.2" strip-json-comments "^3.1.1" -"@eslint/js@9.20.0": - version "9.20.0" - resolved "https://registry.yarnpkg.com/@eslint/js/-/js-9.20.0.tgz#7421bcbe74889fcd65d1be59f00130c289856eb4" - integrity sha512-iZA07H9io9Wn836aVTytRaNqh00Sad+EamwOVJT12GTLw1VGMFV/4JaME+JjLtr9fiGaoWgYnS54wrfWsSs4oQ== +"@eslint/js@9.21.0": + version "9.21.0" + resolved "https://registry.yarnpkg.com/@eslint/js/-/js-9.21.0.tgz#4303ef4e07226d87c395b8fad5278763e9c15c08" + integrity sha512-BqStZ3HX8Yz6LvsF5ByXYrtigrV5AXADWLAGc7PH/1SxOb7/FIYYMszZZWiUou/GB9P2lXWk2SV4d+Z8h0nknw== -"@eslint/object-schema@^2.1.5": - version "2.1.5" - resolved "https://registry.yarnpkg.com/@eslint/object-schema/-/object-schema-2.1.5.tgz#8670a8f6258a2be5b2c620ff314a1d984c23eb2e" - integrity sha512-o0bhxnL89h5Bae5T318nFoFzGy+YE5i/gGkoPAgkmTVdRKTiv3p8JHevPiPaMwoloKfEiiaHlawCqaZMqRm+XQ== +"@eslint/object-schema@^2.1.6": + version "2.1.6" + resolved "https://registry.yarnpkg.com/@eslint/object-schema/-/object-schema-2.1.6.tgz#58369ab5b5b3ca117880c0f6c0b0f32f6950f24f" + integrity sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA== -"@eslint/plugin-kit@^0.2.5": - version "0.2.5" - resolved "https://registry.yarnpkg.com/@eslint/plugin-kit/-/plugin-kit-0.2.5.tgz#ee07372035539e7847ef834e3f5e7b79f09e3a81" - integrity sha512-lB05FkqEdUg2AA0xEbUz0SnkXT1LcCTa438W4IWTUh4hdOnVbQyOJ81OrDXsJk/LSiJHubgGEFoR5EHq1NsH1A== +"@eslint/plugin-kit@^0.2.7": + version "0.2.7" + resolved "https://registry.yarnpkg.com/@eslint/plugin-kit/-/plugin-kit-0.2.7.tgz#9901d52c136fb8f375906a73dcc382646c3b6a27" + integrity sha512-JubJ5B2pJ4k4yGxaNLdbjrnk9d/iDz6/q8wOilpIowd6PJPgaxCuHBnBszq7Ce2TyMrywm5r4PnKm6V3iiZF+g== dependencies: - "@eslint/core" "^0.10.0" + "@eslint/core" "^0.12.0" levn "^0.4.1" "@fastify/busboy@^1.2.1": @@ -2927,10 +2920,10 @@ resolved "https://registry.yarnpkg.com/@humanwhocodes/retry/-/retry-0.3.1.tgz#c72a5c76a9fbaf3488e231b13dc52c0da7bab42a" integrity sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA== -"@humanwhocodes/retry@^0.4.1": - version "0.4.1" - resolved "https://registry.yarnpkg.com/@humanwhocodes/retry/-/retry-0.4.1.tgz#9a96ce501bc62df46c4031fbd970e3cc6b10f07b" - integrity sha512-c7hNEllBlenFTHBky65mhq8WD2kbN9Q6gk0bTk8lSBvc554jpXSkST1iePudpt7+A/AQvuHs9EMqjHDXMY1lrA== +"@humanwhocodes/retry@^0.4.2": + version "0.4.2" + resolved "https://registry.yarnpkg.com/@humanwhocodes/retry/-/retry-0.4.2.tgz#1860473de7dfa1546767448f333db80cb0ff2161" + integrity sha512-xeO57FpIu4p1Ri3Jq/EXq4ClRm86dVF2z/+kvFnyqVYRavTZmaFaUBbWCOuuTh0o/g7DSsk6kc2vrS4Vl5oPOQ== "@isaacs/cliui@^8.0.2": version "8.0.2" @@ -4627,36 +4620,20 @@ dependencies: "@types/yargs-parser" "*" -"@typescript-eslint/eslint-plugin@8.21.0": - version "8.21.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.21.0.tgz#395014a75112ecdb81142b866ab6bb62e3be0f2a" - integrity sha512-eTH+UOR4I7WbdQnG4Z48ebIA6Bgi7WO8HvFEneeYBxG8qCOYgTOFPSg6ek9ITIDvGjDQzWHcoWHCDO2biByNzA== +"@typescript-eslint/eslint-plugin@8.24.1": + version "8.24.1" + resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.24.1.tgz#d104c2a6212304c649105b18af2c110b4a1dd4ae" + integrity sha512-ll1StnKtBigWIGqvYDVuDmXJHVH4zLVot1yQ4fJtLpL7qacwkxJc1T0bptqw+miBQ/QfUbhl1TcQ4accW5KUyA== dependencies: "@eslint-community/regexpp" "^4.10.0" - "@typescript-eslint/scope-manager" "8.21.0" - "@typescript-eslint/type-utils" "8.21.0" - "@typescript-eslint/utils" "8.21.0" - "@typescript-eslint/visitor-keys" "8.21.0" + "@typescript-eslint/scope-manager" "8.24.1" + "@typescript-eslint/type-utils" "8.24.1" + "@typescript-eslint/utils" "8.24.1" + "@typescript-eslint/visitor-keys" "8.24.1" graphemer "^1.4.0" ignore "^5.3.1" natural-compare "^1.4.0" - ts-api-utils "^2.0.0" - -"@typescript-eslint/eslint-plugin@^5.62.0": - version "5.62.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz#aeef0328d172b9e37d9bab6dbc13b87ed88977db" - integrity sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag== - dependencies: - "@eslint-community/regexpp" "^4.4.0" - "@typescript-eslint/scope-manager" "5.62.0" - "@typescript-eslint/type-utils" "5.62.0" - "@typescript-eslint/utils" "5.62.0" - debug "^4.3.4" - graphemer "^1.4.0" - ignore "^5.2.0" - natural-compare-lite "^1.4.0" - semver "^7.3.7" - tsutils "^3.21.0" + ts-api-utils "^2.0.1" "@typescript-eslint/experimental-utils@^5.59.11": version "5.62.0" @@ -4665,25 +4642,15 @@ dependencies: "@typescript-eslint/utils" "5.62.0" -"@typescript-eslint/parser@8.21.0": - version "8.21.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-8.21.0.tgz#312c638aaba4f640d45bfde7c6795a9d75deb088" - integrity sha512-Wy+/sdEH9kI3w9civgACwabHbKl+qIOu0uFZ9IMKzX3Jpv9og0ZBJrZExGrPpFAY7rWsXuxs5e7CPPP17A4eYA== - dependencies: - "@typescript-eslint/scope-manager" "8.21.0" - "@typescript-eslint/types" "8.21.0" - "@typescript-eslint/typescript-estree" "8.21.0" - "@typescript-eslint/visitor-keys" "8.21.0" - debug "^4.3.4" - -"@typescript-eslint/parser@^5.62.0": - version "5.62.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.62.0.tgz#1b63d082d849a2fcae8a569248fbe2ee1b8a56c7" - integrity sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA== +"@typescript-eslint/parser@8.24.1": + version "8.24.1" + resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-8.24.1.tgz#67965c2d2ddd7eadb2f094c395695db8334ef9a2" + integrity sha512-Tqoa05bu+t5s8CTZFaGpCH2ub3QeT9YDkXbPd3uQ4SfsLoh1/vv2GEYAioPoxCWJJNsenXlC88tRjwoHNts1oQ== dependencies: - "@typescript-eslint/scope-manager" "5.62.0" - "@typescript-eslint/types" "5.62.0" - "@typescript-eslint/typescript-estree" "5.62.0" + "@typescript-eslint/scope-manager" "8.24.1" + "@typescript-eslint/types" "8.24.1" + "@typescript-eslint/typescript-estree" "8.24.1" + "@typescript-eslint/visitor-keys" "8.24.1" debug "^4.3.4" "@typescript-eslint/parser@^8.10.0": @@ -4757,15 +4724,13 @@ "@typescript-eslint/types" "8.21.0" "@typescript-eslint/visitor-keys" "8.21.0" -"@typescript-eslint/type-utils@5.62.0", "@typescript-eslint/type-utils@^5.55.0", "@typescript-eslint/type-utils@^5.62.0": - version "5.62.0" - resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz#286f0389c41681376cdad96b309cedd17d70346a" - integrity sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew== +"@typescript-eslint/scope-manager@8.24.1": + version "8.24.1" + resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-8.24.1.tgz#1e1e76ec4560aa85077ab36deb9b2bead4ae124e" + integrity sha512-OdQr6BNBzwRjNEXMQyaGyZzgg7wzjYKfX2ZBV3E04hUCBDv3GQCHiz9RpqdUIiVrMgJGkXm3tcEh4vFSHreS2Q== dependencies: - "@typescript-eslint/typescript-estree" "5.62.0" - "@typescript-eslint/utils" "5.62.0" - debug "^4.3.4" - tsutils "^3.21.0" + "@typescript-eslint/types" "8.24.1" + "@typescript-eslint/visitor-keys" "8.24.1" "@typescript-eslint/type-utils@8.21.0": version "8.21.0" @@ -4777,6 +4742,26 @@ debug "^4.3.4" ts-api-utils "^2.0.0" +"@typescript-eslint/type-utils@8.24.1": + version "8.24.1" + resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-8.24.1.tgz#99113e1df63d1571309d87eef68967344c78dd65" + integrity sha512-/Do9fmNgCsQ+K4rCz0STI7lYB4phTtEXqqCAs3gZW0pnK7lWNkvWd5iW545GSmApm4AzmQXmSqXPO565B4WVrw== + dependencies: + "@typescript-eslint/typescript-estree" "8.24.1" + "@typescript-eslint/utils" "8.24.1" + debug "^4.3.4" + ts-api-utils "^2.0.1" + +"@typescript-eslint/type-utils@^5.55.0": + version "5.62.0" + resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz#286f0389c41681376cdad96b309cedd17d70346a" + integrity sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew== + dependencies: + "@typescript-eslint/typescript-estree" "5.62.0" + "@typescript-eslint/utils" "5.62.0" + debug "^4.3.4" + tsutils "^3.21.0" + "@typescript-eslint/type-utils@^8.0.0": version "8.12.2" resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-8.12.2.tgz#132b0c52d45f6814e6f2e32416c7951ed480b016" @@ -4817,12 +4802,17 @@ resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-8.21.0.tgz#58f30aec8db8212fd886835dc5969cdf47cb29f5" integrity sha512-PAL6LUuQwotLW2a8VsySDBwYMm129vFm4tMVlylzdoTybTHaAi0oBp7Ac6LhSrHHOdLM3efH+nAR6hAWoMF89A== +"@typescript-eslint/types@8.24.1": + version "8.24.1" + resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-8.24.1.tgz#8777a024f3afc4ace5e48f9a804309c6dd38f95a" + integrity sha512-9kqJ+2DkUXiuhoiYIUvIYjGcwle8pcPpdlfkemGvTObzgmYfJ5d0Qm6jwb4NBXP9W1I5tss0VIAnWFumz3mC5A== + "@typescript-eslint/types@^6.20.0": version "6.20.0" resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-6.20.0.tgz#5ccd74c29011ae7714ae6973e4ec0c634708b448" integrity sha512-MM9mfZMAhiN4cOEcUOEx+0HmuaW3WBfukBZPCfwSqFnQy0grXYtngKCqpQN339X3RrwtzspWJrpbrupKYUSBXQ== -"@typescript-eslint/typescript-estree@5.62.0", "@typescript-eslint/typescript-estree@^5.27.0": +"@typescript-eslint/typescript-estree@5.62.0": version "5.62.0" resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz#7d17794b77fabcac615d6a48fb143330d962eb9b" integrity sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA== @@ -4905,7 +4895,21 @@ semver "^7.6.0" ts-api-utils "^2.0.0" -"@typescript-eslint/utils@5.62.0", "@typescript-eslint/utils@^5.27.0", "@typescript-eslint/utils@^5.62.0": +"@typescript-eslint/typescript-estree@8.24.1": + version "8.24.1" + resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-8.24.1.tgz#3bb479401f8bd471b3c6dd3db89e7256977c54db" + integrity sha512-UPyy4MJ/0RE648DSKQe9g0VDSehPINiejjA6ElqnFaFIhI6ZEiZAkUI0D5MCk0bQcTf/LVqZStvQ6K4lPn/BRg== + dependencies: + "@typescript-eslint/types" "8.24.1" + "@typescript-eslint/visitor-keys" "8.24.1" + debug "^4.3.4" + fast-glob "^3.3.2" + is-glob "^4.0.3" + minimatch "^9.0.4" + semver "^7.6.0" + ts-api-utils "^2.0.1" + +"@typescript-eslint/utils@5.62.0": version "5.62.0" resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.62.0.tgz#141e809c71636e4a75daa39faed2fb5f4b10df86" integrity sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ== @@ -4949,6 +4953,16 @@ "@typescript-eslint/types" "8.21.0" "@typescript-eslint/typescript-estree" "8.21.0" +"@typescript-eslint/utils@8.24.1": + version "8.24.1" + resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-8.24.1.tgz#08d14eac33cfb3456feeee5a275b8ad3349e52ed" + integrity sha512-OOcg3PMMQx9EXspId5iktsI3eMaXVwlhC8BvNnX6B5w9a4dVgpkQZuU8Hy67TolKcl+iFWq0XX+jbDGN4xWxjQ== + dependencies: + "@eslint-community/eslint-utils" "^4.4.0" + "@typescript-eslint/scope-manager" "8.24.1" + "@typescript-eslint/types" "8.24.1" + "@typescript-eslint/typescript-estree" "8.24.1" + "@typescript-eslint/utils@^7.7.1": version "7.18.0" resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-7.18.0.tgz#bca01cde77f95fc6a8d5b0dbcbfb3d6ca4be451f" @@ -5017,6 +5031,14 @@ "@typescript-eslint/types" "8.21.0" eslint-visitor-keys "^4.2.0" +"@typescript-eslint/visitor-keys@8.24.1": + version "8.24.1" + resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-8.24.1.tgz#8bdfe47a89195344b34eb21ef61251562148202b" + integrity sha512-EwVHlp5l+2vp8CoqJm9KikPZgi3gbdZAtabKT9KPShGeOcJhsv4Zdo3oc8T8I0uKEmYoU4ItyxbptjF08enaxg== + dependencies: + "@typescript-eslint/types" "8.24.1" + eslint-visitor-keys "^4.2.0" + "@typescript/lib-decorators@file:./packages/strict-ts-lib/output-branded/packages/decorators": version "5.7.2" dependencies: @@ -8242,19 +8264,18 @@ eslint-import-resolver-node@^0.3.9: is-core-module "^2.13.0" resolve "^1.22.4" -eslint-import-resolver-typescript@3.7.0: - version "3.7.0" - resolved "https://registry.yarnpkg.com/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.7.0.tgz#e69925936a771a9cb2de418ccebc4cdf6c0818aa" - integrity sha512-Vrwyi8HHxY97K5ebydMtffsWAn1SCR9eol49eCd5fJS4O1WV7PaAjbcjmbfJJSMz/t4Mal212Uz/fQZrOB8mow== +eslint-import-resolver-typescript@3.8.3: + version "3.8.3" + resolved "https://registry.yarnpkg.com/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-3.8.3.tgz#1721a1e4417e57a8fe6bf9463d0db8e220285eef" + integrity sha512-A0bu4Ks2QqDWNpeEgTQMPTngaMhuDu4yv6xpftBMAf+1ziXnpx+eSR1WRfoPTe2BAiAjHFZ7kSNx1fvr5g5pmQ== dependencies: "@nolyfill/is-core-module" "1.0.39" debug "^4.3.7" enhanced-resolve "^5.15.0" - fast-glob "^3.3.2" - get-tsconfig "^4.7.5" + get-tsconfig "^4.10.0" is-bun-module "^1.0.2" - is-glob "^4.0.3" stable-hash "^0.0.4" + tinyglobby "^0.2.12" eslint-module-utils@^2.12.0: version "2.12.0" @@ -8375,6 +8396,11 @@ eslint-plugin-react-hooks@5.1.0: resolved "https://registry.yarnpkg.com/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-5.1.0.tgz#3d34e37d5770866c34b87d5b499f5f0b53bf0854" integrity sha512-mpJRtPgHN2tNAvZ35AMfqeB3Xqeo273QxrHJsbBEPWODRM4r0yB6jfoROqKEYrOn27UtRPpcpHc2UqyBSuUNTw== +eslint-plugin-react-perf@3.3.3: + version "3.3.3" + resolved "https://registry.yarnpkg.com/eslint-plugin-react-perf/-/eslint-plugin-react-perf-3.3.3.tgz#29f97ab494fff18dc5e6ec34b056d9a21a86ee71" + integrity sha512-EzPdxsRJg5IllCAH9ny/3nK7sv9251tvKmi/d3Ouv5KzI8TB3zNhzScxL9wnh9Hvv8GYC5LEtzTauynfOEYiAw== + eslint-plugin-react-refresh@0.4.18: version "0.4.18" resolved "https://registry.yarnpkg.com/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.18.tgz#d2ae6dc8d48c87f7722f5304385b0cd8b3a32a54" @@ -8429,26 +8455,6 @@ eslint-plugin-testing-library@7.1.1: "@typescript-eslint/scope-manager" "^8.15.0" "@typescript-eslint/utils" "^8.15.0" -eslint-plugin-total-functions@7.1.0: - version "7.1.0" - resolved "https://registry.yarnpkg.com/eslint-plugin-total-functions/-/eslint-plugin-total-functions-7.1.0.tgz#6ddc1be3d334bf0bf73dc410724dd6d3036f2dd8" - integrity sha512-/ePMd8Pcysm7drAMFH+7b+/P9BBi75aTahE+PgGJigSuvB0dxLXbxbCU+LTbL2N1AZt728l8+JhRMq7IMQ66gA== - dependencies: - "@typescript-eslint/eslint-plugin" "^5.62.0" - "@typescript-eslint/parser" "^5.62.0" - "@typescript-eslint/type-utils" "^5.62.0" - "@typescript-eslint/utils" "^5.62.0" - is-immutable-type "^1.2.9" - tsutils "^3.21.0" - -eslint-plugin-tree-shakable@1.2.0: - version "1.2.0" - resolved "https://registry.yarnpkg.com/eslint-plugin-tree-shakable/-/eslint-plugin-tree-shakable-1.2.0.tgz#2802fff6dafb5962549588f90453c10b04de2f04" - integrity sha512-+DsSUdd5U30pIUgXp/LZoyvZW8plrptRbuMul78VXeRjMKdAZxvJZviRYoAnBE8QwPT8Xe35wLBHCppjO489Eg== - dependencies: - "@typescript-eslint/typescript-estree" "^5.27.0" - "@typescript-eslint/utils" "^5.27.0" - eslint-plugin-unicorn@56.0.1: version "56.0.1" resolved "https://registry.yarnpkg.com/eslint-plugin-unicorn/-/eslint-plugin-unicorn-56.0.1.tgz#d10a3df69ba885939075bdc95a65a0c872e940d4" @@ -8516,21 +8522,21 @@ eslint-visitor-keys@^4.2.0: resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz#687bacb2af884fcdda8a6e7d65c606f46a14cd45" integrity sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw== -eslint@9.20.1: - version "9.20.1" - resolved "https://registry.yarnpkg.com/eslint/-/eslint-9.20.1.tgz#923924c078f5226832449bac86662dd7e53c91d6" - integrity sha512-m1mM33o6dBUjxl2qb6wv6nGNwCAsns1eKtaQ4l/NPHeTvhiUPbtdfMyktxN4B3fgHIgsYh1VT3V9txblpQHq+g== +eslint@9.21.0: + version "9.21.0" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-9.21.0.tgz#b1c9c16f5153ff219791f627b94ab8f11f811591" + integrity sha512-KjeihdFqTPhOMXTt7StsDxriV4n66ueuF/jfPNC3j/lduHwr/ijDwJMsF+wyMJethgiKi5wniIE243vi07d3pg== dependencies: "@eslint-community/eslint-utils" "^4.2.0" "@eslint-community/regexpp" "^4.12.1" - "@eslint/config-array" "^0.19.0" - "@eslint/core" "^0.11.0" - "@eslint/eslintrc" "^3.2.0" - "@eslint/js" "9.20.0" - "@eslint/plugin-kit" "^0.2.5" + "@eslint/config-array" "^0.19.2" + "@eslint/core" "^0.12.0" + "@eslint/eslintrc" "^3.3.0" + "@eslint/js" "9.21.0" + "@eslint/plugin-kit" "^0.2.7" "@humanfs/node" "^0.16.6" "@humanwhocodes/module-importer" "^1.0.1" - "@humanwhocodes/retry" "^0.4.1" + "@humanwhocodes/retry" "^0.4.2" "@types/estree" "^1.0.6" "@types/json-schema" "^7.0.15" ajv "^6.12.4" @@ -8995,6 +9001,11 @@ fdir@^6.4.2: resolved "https://registry.yarnpkg.com/fdir/-/fdir-6.4.2.tgz#ddaa7ce1831b161bc3657bb99cb36e1622702689" integrity sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ== +fdir@^6.4.3: + version "6.4.3" + resolved "https://registry.yarnpkg.com/fdir/-/fdir-6.4.3.tgz#011cdacf837eca9b811c89dbb902df714273db72" + integrity sha512-PMXmW2y1hDDfTSRc9gaXIuCCRpuoz3Kaz8cUelp3smouvfT632ozg2vrT6lJsHKKOF59YLbOGfAWGUcKEfRMQw== + fecha@^4.2.0: version "4.2.3" resolved "https://registry.yarnpkg.com/fecha/-/fecha-4.2.3.tgz#4d9ccdbc61e8629b259fdca67e65891448d569fd" @@ -9691,10 +9702,10 @@ get-symbol-description@^1.1.0: es-errors "^1.3.0" get-intrinsic "^1.2.6" -get-tsconfig@^4.7.5: - version "4.8.1" - resolved "https://registry.yarnpkg.com/get-tsconfig/-/get-tsconfig-4.8.1.tgz#8995eb391ae6e1638d251118c7b56de7eb425471" - integrity sha512-k9PN+cFBmaLWtVz29SkUoqU5O0slLuHJXt/2P+tMVFT+phsSGXGkp9t3rQIqdz0e+06EHNGs3oM6ZX1s2zHxRg== +get-tsconfig@^4.10.0: + version "4.10.0" + resolved "https://registry.yarnpkg.com/get-tsconfig/-/get-tsconfig-4.10.0.tgz#403a682b373a823612475a4c2928c7326fc0f6bb" + integrity sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A== dependencies: resolve-pkg-maps "^1.0.0" @@ -9814,10 +9825,10 @@ global-dirs@^3.0.0: dependencies: ini "2.0.0" -globals@15.14.0: - version "15.14.0" - resolved "https://registry.yarnpkg.com/globals/-/globals-15.14.0.tgz#b8fd3a8941ff3b4d38f3319d433b61bbb482e73f" - integrity sha512-OkToC372DtlQeje9/zHIo5CT8lRP/FUgEOKBEhU4e0abL7J7CD24fD9ohiLN5hagG/kWCYj4K5oaxxtj2Z0Dig== +globals@16.0.0: + version "16.0.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-16.0.0.tgz#3d7684652c5c4fbd086ec82f9448214da49382d8" + integrity sha512-iInW14XItCXET01CQFqudPOWP2jYMl7T+QRQT+UNcR/iQncN/F0UNpgd76iFkBPgNQb4+X3LV9tLJYzwh+Gl3A== globals@^11.1.0: version "11.12.0" @@ -10941,7 +10952,7 @@ is-hexadecimal@^2.0.0: resolved "https://registry.yarnpkg.com/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz#86b5bf668fca307498d319dfc03289d781a90027" integrity sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg== -is-immutable-type@1.2.9, is-immutable-type@^1.2.9: +is-immutable-type@1.2.9: version "1.2.9" resolved "https://registry.yarnpkg.com/is-immutable-type/-/is-immutable-type-1.2.9.tgz#80f066f482af26f36a3dc6c18450cda0ba293c05" integrity sha512-DDx04RjLpGNT4vtF49vGW5CECP6lAx8SL2keq99ogIxwLvJPBvgThdhb43ED5uYO4nq0kZ51tMj7VdCCQgdZ5Q== @@ -12997,11 +13008,6 @@ nanomatch@^1.2.9: snapdragon "^0.8.1" to-regex "^3.0.1" -natural-compare-lite@^1.4.0: - version "1.4.0" - resolved "https://registry.yarnpkg.com/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz#17b09581988979fddafe0201e931ba933c96cbb4" - integrity sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g== - natural-compare@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" @@ -16181,6 +16187,14 @@ tinyexec@^0.3.1: resolved "https://registry.yarnpkg.com/tinyexec/-/tinyexec-0.3.1.tgz#0ab0daf93b43e2c211212396bdb836b468c97c98" integrity sha512-WiCJLEECkO18gwqIp6+hJg0//p23HXp4S+gGtAKu3mI2F2/sXC4FvHvXvB0zJVVaTPhx1/tOwdbRsa1sOBIKqQ== +tinyglobby@^0.2.12: + version "0.2.12" + resolved "https://registry.yarnpkg.com/tinyglobby/-/tinyglobby-0.2.12.tgz#ac941a42e0c5773bd0b5d08f32de82e74a1a61b5" + integrity sha512-qkf4trmKSIiMTs/E63cxH+ojC2unam7rJ0WrauAzpT3ECNTxGRMlaXxVbfxMUC/w0LaYk6jQ4y/nGR9uBO3tww== + dependencies: + fdir "^6.4.3" + picomatch "^4.0.2" + tinyglobby@^0.2.9: version "0.2.10" resolved "https://registry.yarnpkg.com/tinyglobby/-/tinyglobby-0.2.10.tgz#e712cf2dc9b95a1f5c5bbd159720e15833977a0f" @@ -16307,6 +16321,11 @@ ts-api-utils@^2.0.0: resolved "https://registry.yarnpkg.com/ts-api-utils/-/ts-api-utils-2.0.0.tgz#b9d7d5f7ec9f736f4d0f09758b8607979044a900" integrity sha512-xCt/TOAc+EOHS1XPnijD3/yzpH6qg2xppZO1YDqGoVsNXfQfzHpOdNuXwrwOU8u4ITXJyDCTyt8w5g1sZv9ynQ== +ts-api-utils@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/ts-api-utils/-/ts-api-utils-2.0.1.tgz#660729385b625b939aaa58054f45c058f33f10cd" + integrity sha512-dnlgjFSVetynI8nzgJ+qF62efpglpWRk8isUEWZGWlJYySCTD6aKvbUDu+zbPeDakk3bg5H4XpitHukgfL1m9w== + ts-declaration-location@^1.0.4: version "1.0.4" resolved "https://registry.yarnpkg.com/ts-declaration-location/-/ts-declaration-location-1.0.4.tgz#60c64133202ec5d171fdf0395f70f786f92f14c0" @@ -16588,14 +16607,14 @@ typedarray-to-buffer@^3.1.5: dependencies: is-typedarray "^1.0.0" -typescript-eslint@8.21.0: - version "8.21.0" - resolved "https://registry.yarnpkg.com/typescript-eslint/-/typescript-eslint-8.21.0.tgz#78bdb83a6d771f0312b128297d84a3111885fd08" - integrity sha512-txEKYY4XMKwPXxNkN8+AxAdX6iIJAPiJbHE/FpQccs/sxw8Lf26kqwC3cn0xkHlW8kEbLhkhCsjWuMveaY9Rxw== +typescript-eslint@8.24.1: + version "8.24.1" + resolved "https://registry.yarnpkg.com/typescript-eslint/-/typescript-eslint-8.24.1.tgz#ce85d791392608a2a9f80c4b2530a214d16a2a47" + integrity sha512-cw3rEdzDqBs70TIcb0Gdzbt6h11BSs2pS0yaq7hDWDBtCCSei1pPSUXE9qUdQ/Wm9NgFg8mKtMt1b8fTHIl1jA== dependencies: - "@typescript-eslint/eslint-plugin" "8.21.0" - "@typescript-eslint/parser" "8.21.0" - "@typescript-eslint/utils" "8.21.0" + "@typescript-eslint/eslint-plugin" "8.24.1" + "@typescript-eslint/parser" "8.24.1" + "@typescript-eslint/utils" "8.24.1" typescript-json-schema@^0.65.1: version "0.65.1" @@ -17428,6 +17447,7 @@ wordwrapjs@^5.1.0: integrity sha512-JNjcULU2e4KJwUNv6CHgI46UvDGitb6dGryHajXTDiLgg1/RiGoPSDw4kZfYnwGtEXf2ZMeIewDQgFGzkCB2Sg== "wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0: + name wrap-ansi-cjs version "7.0.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== From cff946e806ec3e8819914714bcbbd4e9770f30a0 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sat, 22 Feb 2025 19:42:24 +0900 Subject: [PATCH 22/25] chore: [eslint-configs] remove category from JSDoc --- .../scripts/generate-rules-type-core.mts | 3 +- .../eslint-configs/src/configs/plugins.mts | 1 + .../rules/unsafe-assignment-rule.mts | 6 +- .../src/types/rules/eslint-cypress-rules.mts | 110 +- .../types/rules/eslint-functional-rules.mts | 222 ++-- .../src/types/rules/eslint-import-rules.mts | 437 ++++---- .../types/rules/eslint-playwright-rules.mts | 574 +++++----- .../src/types/rules/eslint-plugin-rules.mts | 31 - .../types/rules/eslint-react-perf-rules.mts | 4 - .../src/types/rules/eslint-react-rules.mts | 997 ++++++++---------- .../src/types/rules/eslint-security-rules.mts | 154 ++- 11 files changed, 1132 insertions(+), 1407 deletions(-) diff --git a/packages/eslint-configs/scripts/generate-rules-type-core.mts b/packages/eslint-configs/scripts/generate-rules-type-core.mts index cce04748fd..31e0fb097a 100644 --- a/packages/eslint-configs/scripts/generate-rules-type-core.mts +++ b/packages/eslint-configs/scripts/generate-rules-type-core.mts @@ -58,14 +58,13 @@ const metaToString = (meta: DeepReadonly): string => { if (docs === undefined) return ''; - const { description, recommended, category, url } = docs; + const { description, recommended, url } = docs; const keyValue: DeepReadonly<[string, boolean | string | undefined][]> = [ ['type', type], ['deprecated', isDeprecated(deprecated)], ['fixable', fixable], ['hasSuggestions', hasSuggestions], - ['category', category], ['recommended', recommended], [ 'requiresTypeChecking', diff --git a/packages/eslint-configs/src/configs/plugins.mts b/packages/eslint-configs/src/configs/plugins.mts index 3c4576942d..55f253075e 100644 --- a/packages/eslint-configs/src/configs/plugins.mts +++ b/packages/eslint-configs/src/configs/plugins.mts @@ -103,6 +103,7 @@ export const plugins: Record< 'react-hooks': eslintPluginReactHooks, // eslint-disable-next-line total-functions/no-unsafe-type-assertion 'react-refresh': eslintPluginReactRefresh as unknown as Plugin, + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment 'react-perf': eslintPluginReactPerf, // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment security: eslintPluginSecurity, diff --git a/packages/eslint-configs/src/plugins/total-functions/rules/unsafe-assignment-rule.mts b/packages/eslint-configs/src/plugins/total-functions/rules/unsafe-assignment-rule.mts index e4ecfa1e1e..d8e36c191b 100644 --- a/packages/eslint-configs/src/plugins/total-functions/rules/unsafe-assignment-rule.mts +++ b/packages/eslint-configs/src/plugins/total-functions/rules/unsafe-assignment-rule.mts @@ -238,7 +238,7 @@ export const createNoUnsafeAssignmentRule = // TODO fix this copypasta between YieldExpression and ReturnStatement YieldExpression: (node): void => { - if (node.argument === undefined) { + if (node.argument === null) { return; } @@ -257,7 +257,7 @@ export const createNoUnsafeAssignmentRule = const sourceType = checker.getTypeAtLocation(tsNode.expression); const arrayMethodCallSafety = isSafeAssignmentFromArrayMethod( - node.argument ?? undefined, + node.argument, destinationType, sourceType, ); @@ -272,7 +272,7 @@ export const createNoUnsafeAssignmentRule = checker, destinationType, sourceType, - node.argument ?? undefined, + node.argument, ) === 'unsafe' ) { context.report({ diff --git a/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts b/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts index 5deb064804..1ac9831fca 100644 --- a/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-cypress-rules.mts @@ -14,12 +14,11 @@ type SpreadOptionsIfIsArray< * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-assigning-return-values.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoAssigningReturnValues { @@ -32,12 +31,11 @@ namespace NoAssigningReturnValues { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/unsafe-to-chain-command.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace UnsafeToChainCommand { @@ -80,12 +78,11 @@ namespace UnsafeToChainCommand { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-unnecessary-waiting.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoUnnecessaryWaiting { @@ -98,12 +95,11 @@ namespace NoUnnecessaryWaiting { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-async-before.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoAsyncBefore { @@ -116,12 +112,11 @@ namespace NoAsyncBefore { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-async-tests.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoAsyncTests { @@ -134,12 +129,11 @@ namespace NoAsyncTests { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/assertion-before-screenshot.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | false | * ``` */ namespace AssertionBeforeScreenshot { @@ -152,12 +146,11 @@ namespace AssertionBeforeScreenshot { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/require-data-selectors.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace RequireDataSelectors { @@ -170,12 +163,11 @@ namespace RequireDataSelectors { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-force.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoForce { @@ -188,12 +180,11 @@ namespace NoForce { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-pause.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoPause { @@ -206,12 +197,11 @@ namespace NoPause { * @link https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-debug.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoDebug { diff --git a/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts b/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts index 03cf14877d..d626d7a4c8 100644 --- a/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-functional-rules.mts @@ -18,7 +18,6 @@ type SpreadOptionsIfIsArray< * | :------------------- | :---------- | * | type | suggestion | * | deprecated | false | - * | category | Currying | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -694,13 +693,12 @@ namespace FunctionalParameters { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/immutable-data.md * * ```md - * | key | value | - * | :------------------- | :----------- | - * | type | suggestion | - * | deprecated | false | - * | category | No Mutations | - * | recommended | recommended | - * | requiresTypeChecking | true | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | true | * ``` */ namespace ImmutableData { @@ -1338,13 +1336,12 @@ namespace ImmutableData { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-classes.md * * ```md - * | key | value | - * | :------------------- | :----------------- | - * | type | suggestion | - * | deprecated | false | - * | category | No Other Paradigms | - * | recommended | recommended | - * | requiresTypeChecking | false | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | false | * ``` */ namespace NoClasses { @@ -1397,13 +1394,12 @@ namespace NoClasses { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-class-inheritance.md * * ```md - * | key | value | - * | :------------------- | :----------------- | - * | type | suggestion | - * | deprecated | false | - * | category | No Other Paradigms | - * | recommended | recommended | - * | requiresTypeChecking | false | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | false | * ``` */ namespace NoClassInheritance { @@ -1456,13 +1452,12 @@ namespace NoClassInheritance { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-conditional-statements.md * * ```md - * | key | value | - * | :------------------- | :------------ | - * | type | suggestion | - * | deprecated | false | - * | category | No Statements | - * | recommended | recommended | - * | requiresTypeChecking | true | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | true | * ``` */ namespace NoConditionalStatements { @@ -1509,13 +1504,12 @@ namespace NoConditionalStatements { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-expression-statements.md * * ```md - * | key | value | - * | :------------------- | :------------ | - * | type | suggestion | - * | deprecated | false | - * | category | No Statements | - * | recommended | recommended | - * | requiresTypeChecking | true | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | true | * ``` */ namespace NoExpressionStatements { @@ -1566,13 +1560,12 @@ namespace NoExpressionStatements { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-let.md * * ```md - * | key | value | - * | :------------------- | :----------- | - * | type | suggestion | - * | deprecated | false | - * | category | No Mutations | - * | recommended | recommended | - * | requiresTypeChecking | false | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | false | * ``` */ namespace NoLet { @@ -1623,13 +1616,12 @@ namespace NoLet { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-loop-statements.md * * ```md - * | key | value | - * | :------------------- | :------------ | - * | type | suggestion | - * | deprecated | false | - * | category | No Statements | - * | recommended | recommended | - * | requiresTypeChecking | false | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | false | * ``` */ namespace NoLoopStatements { @@ -1642,13 +1634,12 @@ namespace NoLoopStatements { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-mixed-types.md * * ```md - * | key | value | - * | :------------------- | :----------------- | - * | type | suggestion | - * | deprecated | false | - * | category | No Other Paradigms | - * | recommended | recommended | - * | requiresTypeChecking | true | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | true | * ``` */ namespace NoMixedTypes { @@ -1689,13 +1680,12 @@ namespace NoMixedTypes { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-promise-reject.md * * ```md - * | key | value | - * | :------------------- | :------------ | - * | type | suggestion | - * | deprecated | false | - * | category | No Exceptions | - * | recommended | false | - * | requiresTypeChecking | false | + * | key | value | + * | :------------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | + * | requiresTypeChecking | false | * ``` */ namespace NoPromiseReject { @@ -1708,13 +1698,12 @@ namespace NoPromiseReject { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-return-void.md * * ```md - * | key | value | - * | :------------------- | :------------ | - * | type | suggestion | - * | deprecated | false | - * | category | No Statements | - * | recommended | recommended | - * | requiresTypeChecking | true | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | true | * ``` */ namespace NoReturnVoid { @@ -1759,13 +1748,12 @@ namespace NoReturnVoid { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-this-expressions.md * * ```md - * | key | value | - * | :------------------- | :----------------- | - * | type | suggestion | - * | deprecated | false | - * | category | No Other Paradigms | - * | recommended | recommended | - * | requiresTypeChecking | false | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | false | * ``` */ namespace NoThisExpressions { @@ -1778,13 +1766,12 @@ namespace NoThisExpressions { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-throw-statements.md * * ```md - * | key | value | - * | :------------------- | :------------ | - * | type | suggestion | - * | deprecated | false | - * | category | No Exceptions | - * | recommended | recommended | - * | requiresTypeChecking | false | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | false | * ``` */ namespace NoThrowStatements { @@ -1821,13 +1808,12 @@ namespace NoThrowStatements { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/no-try-statements.md * * ```md - * | key | value | - * | :------------------- | :------------ | - * | type | suggestion | - * | deprecated | false | - * | category | No Exceptions | - * | recommended | recommended | - * | requiresTypeChecking | false | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | recommended | + * | requiresTypeChecking | false | * ``` */ namespace NoTryStatements { @@ -1868,15 +1854,14 @@ namespace NoTryStatements { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/prefer-immutable-types.md * * ```md - * | key | value | - * | :------------------- | :----------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | hasSuggestions | true | - * | category | No Mutations | - * | recommended | recommended | - * | requiresTypeChecking | true | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | hasSuggestions | true | + * | recommended | recommended | + * | requiresTypeChecking | true | * ``` */ namespace PreferImmutableTypes { @@ -3658,7 +3643,6 @@ namespace PreferImmutableTypes { * | :------------------- | :---------- | * | type | suggestion | * | deprecated | false | - * | category | Stylistic | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -3698,14 +3682,13 @@ namespace PreferPropertySignatures { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/prefer-readonly-type.md * * ```md - * | key | value | - * | :------------------- | :----------- | - * | type | suggestion | - * | deprecated | true | - * | fixable | code | - * | category | No Mutations | - * | recommended | recommended | - * | requiresTypeChecking | true | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | true | + * | fixable | code | + * | recommended | recommended | + * | requiresTypeChecking | true | * ``` */ namespace PreferReadonlyType { @@ -3774,7 +3757,6 @@ namespace PreferReadonlyType { * | type | suggestion | * | deprecated | false | * | hasSuggestions | true | - * | category | Stylistic | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -3818,7 +3800,6 @@ namespace PreferTacit { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Stylistic | * | recommended | recommended | * | requiresTypeChecking | true | * ``` @@ -3853,15 +3834,14 @@ namespace ReadonlyType { * @link https://github.com/eslint-functional/eslint-plugin-functional/blob/v7.1.0/docs/rules/type-declaration-immutability.md * * ```md - * | key | value | - * | :------------------- | :----------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | hasSuggestions | true | - * | category | No Mutations | - * | recommended | recommended | - * | requiresTypeChecking | true | + * | key | value | + * | :------------------- | :---------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | hasSuggestions | true | + * | recommended | recommended | + * | requiresTypeChecking | true | * ``` */ namespace TypeDeclarationImmutability { diff --git a/packages/eslint-configs/src/types/rules/eslint-import-rules.mts b/packages/eslint-configs/src/types/rules/eslint-import-rules.mts index d6119f0636..42d5aec268 100644 --- a/packages/eslint-configs/src/types/rules/eslint-import-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-import-rules.mts @@ -14,11 +14,10 @@ type SpreadOptionsIfIsArray< * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-unresolved.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoUnresolved { @@ -83,11 +82,10 @@ namespace NoUnresolved { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/named.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace Named { @@ -124,11 +122,10 @@ namespace Named { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/default.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace Default { @@ -142,11 +139,10 @@ namespace Default { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/namespace.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace Namespace { @@ -189,12 +185,11 @@ namespace Namespace { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-namespace.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoNamespace { @@ -235,11 +230,10 @@ namespace NoNamespace { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/export.md * * ```md - * | key | value | - * | :--------- | :--------------- | - * | type | problem | - * | deprecated | false | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace Export { @@ -252,11 +246,10 @@ namespace Export { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-mutable-exports.md * * ```md - * | key | value | - * | :--------- | :--------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoMutableExports { @@ -269,11 +262,10 @@ namespace NoMutableExports { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/extensions.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace Extensions { @@ -424,11 +416,10 @@ namespace Extensions { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-restricted-paths.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoRestrictedPaths { @@ -530,11 +521,10 @@ namespace NoRestrictedPaths { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-internal-modules.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoInternalModules { @@ -594,11 +584,10 @@ namespace NoInternalModules { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/group-exports.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace GroupExports { @@ -611,12 +600,11 @@ namespace GroupExports { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-relative-packages.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Static analysis | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoRelativePackages { @@ -671,11 +659,10 @@ namespace NoRelativePackages { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-relative-parent-imports.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoRelativeParentImports { @@ -730,12 +717,11 @@ namespace NoRelativeParentImports { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/consistent-type-specifier-style.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace ConsistentTypeSpecifierStyle { @@ -769,12 +755,11 @@ namespace ConsistentTypeSpecifierStyle { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-self-import.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Static analysis | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoSelfImport { @@ -788,11 +773,10 @@ namespace NoSelfImport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-cycle.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoCycle { @@ -891,11 +875,10 @@ namespace NoCycle { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-named-default.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoNamedDefault { @@ -908,11 +891,10 @@ namespace NoNamedDefault { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-named-as-default.md * * ```md - * | key | value | - * | :--------- | :--------------- | - * | type | problem | - * | deprecated | false | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoNamedAsDefault { @@ -925,11 +907,10 @@ namespace NoNamedAsDefault { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-named-as-default-member.md * * ```md - * | key | value | - * | :--------- | :--------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoNamedAsDefaultMember { @@ -942,11 +923,10 @@ namespace NoNamedAsDefaultMember { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-anonymous-default-export.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoAnonymousDefaultExport { @@ -1028,11 +1008,10 @@ namespace NoAnonymousDefaultExport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-unused-modules.md * * ```md - * | key | value | - * | :--------- | :--------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoUnusedModules { @@ -1146,11 +1125,10 @@ namespace NoUnusedModules { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-commonjs.md * * ```md - * | key | value | - * | :--------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Module systems | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoCommonjs { @@ -1217,11 +1195,10 @@ namespace NoCommonjs { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-amd.md * * ```md - * | key | value | - * | :--------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Module systems | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoAmd { @@ -1234,12 +1211,11 @@ namespace NoAmd { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-duplicates.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | problem | - * | deprecated | false | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoDuplicates { @@ -1280,12 +1256,11 @@ namespace NoDuplicates { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/first.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace First { @@ -1318,11 +1293,10 @@ namespace First { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/max-dependencies.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace MaxDependencies { @@ -1363,11 +1337,10 @@ namespace MaxDependencies { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-extraneous-dependencies.md * * ```md - * | key | value | - * | :--------- | :--------------- | - * | type | problem | - * | deprecated | false | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoExtraneousDependencies { @@ -1447,12 +1420,11 @@ namespace NoExtraneousDependencies { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-absolute-path.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Static analysis | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoAbsolutePath { @@ -1507,11 +1479,10 @@ namespace NoAbsolutePath { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-nodejs-modules.md * * ```md - * | key | value | - * | :--------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Module systems | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoNodejsModules { @@ -1552,11 +1523,10 @@ namespace NoNodejsModules { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-webpack-loader-syntax.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :------ | + * | type | problem | + * | deprecated | false | * ``` */ namespace NoWebpackLoaderSyntax { @@ -1569,12 +1539,11 @@ namespace NoWebpackLoaderSyntax { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/order.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace Order { @@ -1771,12 +1740,11 @@ namespace Order { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/newline-after-import.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | layout | - * | deprecated | false | - * | fixable | whitespace | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | layout | + * | deprecated | false | + * | fixable | whitespace | * ``` */ namespace NewlineAfterImport { @@ -1822,11 +1790,10 @@ namespace NewlineAfterImport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/prefer-default-export.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace PreferDefaultExport { @@ -1868,11 +1835,10 @@ namespace PreferDefaultExport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-default-export.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoDefaultExport { @@ -1885,11 +1851,10 @@ namespace NoDefaultExport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-named-export.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoNamedExport { @@ -1902,11 +1867,10 @@ namespace NoNamedExport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-dynamic-require.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Static analysis | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoDynamicRequire { @@ -1943,11 +1907,10 @@ namespace NoDynamicRequire { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/unambiguous.md * * ```md - * | key | value | - * | :--------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Module systems | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace Unambiguous { @@ -1960,11 +1923,10 @@ namespace Unambiguous { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-unassigned-import.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoUnassignedImport { @@ -2025,12 +1987,11 @@ namespace NoUnassignedImport { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-useless-path-segments.md * * ```md - * | key | value | - * | :--------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Static analysis | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | * ``` */ namespace NoUselessPathSegments { @@ -2071,12 +2032,11 @@ namespace NoUselessPathSegments { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/dynamic-import-chunkname.md * * ```md - * | key | value | - * | :------------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Style guide | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | * ``` */ namespace DynamicImportChunkname { @@ -2123,13 +2083,12 @@ namespace DynamicImportChunkname { * Forbid import statements with CommonJS module.exports. * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | problem | - * | deprecated | false | - * | fixable | code | - * | category | Module systems | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace NoImportModuleExports { @@ -2166,13 +2125,12 @@ namespace NoImportModuleExports { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-empty-named-blocks.md * * ```md - * | key | value | - * | :------------- | :--------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | hasSuggestions | true | - * | category | Helpful warnings | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | hasSuggestions | true | * ``` */ namespace NoEmptyNamedBlocks { @@ -2185,11 +2143,10 @@ namespace NoEmptyNamedBlocks { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/exports-last.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | false | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace ExportsLast { @@ -2202,11 +2159,10 @@ namespace ExportsLast { * @link https://github.com/import-js/eslint-plugin-import/blob/v2.31.0/docs/rules/no-deprecated.md * * ```md - * | key | value | - * | :--------- | :--------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Helpful warnings | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | false | * ``` */ namespace NoDeprecated { @@ -2219,12 +2175,11 @@ namespace NoDeprecated { * @link https://github.com/import-js/eslint-plugin-import/blob/7b25c1cb95ee18acc1531002fd343e1e6031f9ed/docs/rules/imports-first.md * * ```md - * | key | value | - * | :--------- | :---------- | - * | type | suggestion | - * | deprecated | true | - * | fixable | code | - * | category | Style guide | + * | key | value | + * | :--------- | :--------- | + * | type | suggestion | + * | deprecated | true | + * | fixable | code | * ``` */ namespace ImportsFirst { diff --git a/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts b/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts index 3e7a8e9b34..7b9b8929de 100644 --- a/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-playwright-rules.mts @@ -14,12 +14,11 @@ type SpreadOptionsIfIsArray< * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/expect-expect.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | problem | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace ExpectExpect { @@ -61,12 +60,11 @@ namespace ExpectExpect { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/max-expects.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace MaxExpects { @@ -104,12 +102,11 @@ namespace MaxExpects { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/max-nested-describe.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | true | * ``` */ namespace MaxNestedDescribe { @@ -147,13 +144,12 @@ namespace MaxNestedDescribe { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/missing-playwright-await.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | fixable | code | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace MissingPlaywrightAwait { @@ -193,12 +189,11 @@ namespace MissingPlaywrightAwait { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-commented-out-tests.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | problem | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoCommentedOutTests { @@ -211,12 +206,11 @@ namespace NoCommentedOutTests { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-expect.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | problem | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoConditionalExpect { @@ -229,12 +223,11 @@ namespace NoConditionalExpect { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-in-test.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | problem | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoConditionalInTest { @@ -247,12 +240,11 @@ namespace NoConditionalInTest { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-duplicate-hooks.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoDuplicateHooks { @@ -265,13 +257,12 @@ namespace NoDuplicateHooks { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-element-handle.md * * ```md - * | key | value | - * | :------------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | true | * ``` */ namespace NoElementHandle { @@ -285,12 +276,11 @@ namespace NoElementHandle { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-eval.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoEval { @@ -303,13 +293,12 @@ namespace NoEval { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-focused-test.md * * ```md - * | key | value | - * | :------------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :------------- | :------ | + * | type | problem | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | true | * ``` */ namespace NoFocusedTest { @@ -322,12 +311,11 @@ namespace NoFocusedTest { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-force-option.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoForceOption { @@ -340,12 +328,11 @@ namespace NoForceOption { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-get-by-title.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoGetByTitle { @@ -358,12 +345,11 @@ namespace NoGetByTitle { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-hooks.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoHooks { @@ -406,12 +392,11 @@ namespace NoHooks { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-nested-step.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | problem | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoNestedStep { @@ -424,12 +409,11 @@ namespace NoNestedStep { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-networkidle.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoNetworkidle { @@ -442,12 +426,11 @@ namespace NoNetworkidle { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-nth-methods.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | problem | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoNthMethods { @@ -460,12 +443,11 @@ namespace NoNthMethods { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-page-pause.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoPagePause { @@ -478,12 +460,11 @@ namespace NoPagePause { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-raw-locators.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoRawLocators { @@ -523,12 +504,11 @@ namespace NoRawLocators { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-matchers.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoRestrictedMatchers { @@ -563,13 +543,12 @@ namespace NoRestrictedMatchers { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-skipped-test.md * * ```md - * | key | value | - * | :------------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | true | * ``` */ namespace NoSkippedTest { @@ -607,13 +586,12 @@ namespace NoSkippedTest { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-slowed-test.md * * ```md - * | key | value | - * | :------------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | true | * ``` */ namespace NoSlowedTest { @@ -651,13 +629,12 @@ namespace NoSlowedTest { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-standalone-expect.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace NoStandaloneExpect { @@ -670,13 +647,12 @@ namespace NoStandaloneExpect { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-unsafe-references.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | fixable | code | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace NoUnsafeReferences { @@ -689,13 +665,12 @@ namespace NoUnsafeReferences { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-await.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | fixable | code | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace NoUselessAwait { @@ -708,13 +683,12 @@ namespace NoUselessAwait { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-not.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | problem | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace NoUselessNot { @@ -727,13 +701,12 @@ namespace NoUselessNot { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-selector.md * * ```md - * | key | value | - * | :------------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | true | * ``` */ namespace NoWaitForSelector { @@ -746,13 +719,12 @@ namespace NoWaitForSelector { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-timeout.md * * ```md - * | key | value | - * | :------------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | true | * ``` */ namespace NoWaitForTimeout { @@ -765,13 +737,12 @@ namespace NoWaitForTimeout { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-comparison-matcher.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace PreferComparisonMatcher { @@ -784,13 +755,12 @@ namespace PreferComparisonMatcher { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-equality-matcher.md * * ```md - * | key | value | - * | :------------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | false | * ``` */ namespace PreferEqualityMatcher { @@ -803,12 +773,11 @@ namespace PreferEqualityMatcher { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-in-order.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace PreferHooksInOrder { @@ -821,12 +790,11 @@ namespace PreferHooksInOrder { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-on-top.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace PreferHooksOnTop { @@ -839,12 +807,11 @@ namespace PreferHooksOnTop { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-locator.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace PreferLocator { @@ -857,13 +824,12 @@ namespace PreferLocator { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-lowercase-title.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace PreferLowercaseTitle { @@ -920,13 +886,12 @@ namespace PreferLowercaseTitle { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-native-locators.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace PreferNativeLocators { @@ -964,14 +929,13 @@ namespace PreferNativeLocators { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-strict-equal.md * * ```md - * | key | value | - * | :------------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | hasSuggestions | true | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | hasSuggestions | true | + * | recommended | false | * ``` */ namespace PreferStrictEqual { @@ -984,13 +948,12 @@ namespace PreferStrictEqual { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-be.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace PreferToBe { @@ -1003,13 +966,12 @@ namespace PreferToBe { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-contain.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace PreferToContain { @@ -1022,13 +984,12 @@ namespace PreferToContain { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-count.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace PreferToHaveCount { @@ -1041,13 +1002,12 @@ namespace PreferToHaveCount { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-length.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace PreferToHaveLength { @@ -1060,13 +1020,12 @@ namespace PreferToHaveLength { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-web-first-assertions.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace PreferWebFirstAssertions { @@ -1079,12 +1038,11 @@ namespace PreferWebFirstAssertions { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-hook.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace RequireHook { @@ -1142,12 +1100,11 @@ namespace RequireSoftAssertions { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-to-throw-message.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace RequireToThrowMessage { @@ -1160,12 +1117,11 @@ namespace RequireToThrowMessage { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-top-level-describe.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | false | * ``` */ namespace RequireTopLevelDescribe { @@ -1203,12 +1159,11 @@ namespace RequireTopLevelDescribe { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-describe-callback.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace ValidDescribeCallback { @@ -1221,12 +1176,11 @@ namespace ValidDescribeCallback { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | problem | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :------ | + * | type | problem | + * | deprecated | false | + * | recommended | true | * ``` */ namespace ValidExpect { @@ -1269,12 +1223,11 @@ namespace ValidExpect { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect-in-promise.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | recommended | true | * ``` */ namespace ValidExpectInPromise { @@ -1287,13 +1240,12 @@ namespace ValidExpectInPromise { * @link https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-title.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace ValidTitle { diff --git a/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts b/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts index 1f93f3bfbc..ea3d9d1700 100644 --- a/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-plugin-rules.mts @@ -18,7 +18,6 @@ type SpreadOptionsIfIsArray< * | :---------- | :--------- | * | type | suggestion | * | deprecated | false | - * | category | Tests | * | recommended | false | * ``` */ @@ -62,7 +61,6 @@ namespace ConsistentOutput { * | :---------- | :------ | * | type | problem | * | deprecated | false | - * | category | Rules | * | recommended | true | * ``` */ @@ -81,7 +79,6 @@ namespace FixerReturn { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Rules | * | recommended | false | * ``` */ @@ -121,7 +118,6 @@ namespace MetaPropertyOrdering { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Rules | * | recommended | true | * ``` */ @@ -140,7 +136,6 @@ namespace NoDeprecatedContextMethods { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Rules | * | recommended | true | * ``` */ @@ -159,7 +154,6 @@ namespace NoDeprecatedReportApi { * | type | problem | * | deprecated | false | * | fixable | code | - * | category | Tests | * | recommended | true | * ``` */ @@ -177,7 +171,6 @@ namespace NoIdenticalTests { * | :---------- | :--------- | * | type | suggestion | * | deprecated | false | - * | category | Rules | * | recommended | false | * ``` */ @@ -195,7 +188,6 @@ namespace NoMetaSchemaDefault { * | :---------- | :------ | * | type | problem | * | deprecated | false | - * | category | Rules | * | recommended | true | * ``` */ @@ -213,7 +205,6 @@ namespace NoMissingMessageIds { * | :---------- | :------ | * | type | problem | * | deprecated | false | - * | category | Rules | * | recommended | true | * ``` */ @@ -232,7 +223,6 @@ namespace NoMissingPlaceholders { * | type | problem | * | deprecated | false | * | hasSuggestions | true | - * | category | Tests | * | recommended | true | * ``` */ @@ -250,7 +240,6 @@ namespace NoOnlyTests { * | :------------------- | :--------- | * | type | suggestion | * | deprecated | false | - * | category | Rules | * | recommended | false | * | requiresTypeChecking | true | * ``` @@ -301,7 +290,6 @@ namespace NoPropertyInNode { * | :---------- | :------ | * | type | problem | * | deprecated | false | - * | category | Rules | * | recommended | true | * ``` */ @@ -319,7 +307,6 @@ namespace NoUnusedMessageIds { * | :---------- | :------ | * | type | problem | * | deprecated | false | - * | category | Rules | * | recommended | true | * ``` */ @@ -339,7 +326,6 @@ namespace NoUnusedPlaceholders { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Rules | * | recommended | true | * ``` */ @@ -358,7 +344,6 @@ namespace NoUselessTokenRange { * | :---------- | :------ | * | type | problem | * | deprecated | false | - * | category | Rules | * | recommended | true | * ``` */ @@ -377,7 +362,6 @@ namespace PreferMessageIds { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Rules | * | recommended | true | * ``` */ @@ -396,7 +380,6 @@ namespace PreferObjectRule { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Tests | * | recommended | true | * ``` */ @@ -414,7 +397,6 @@ namespace PreferOutputNull { * | :---------- | :--------- | * | type | suggestion | * | deprecated | false | - * | category | Rules | * | recommended | false | * ``` */ @@ -432,7 +414,6 @@ namespace PreferPlaceholders { * | :---------- | :--------- | * | type | suggestion | * | deprecated | false | - * | category | Rules | * | recommended | false | * ``` */ @@ -450,7 +431,6 @@ namespace PreferReplaceText { * | :---------- | :--------- | * | type | suggestion | * | deprecated | false | - * | category | Rules | * | recommended | false | * ``` */ @@ -487,7 +467,6 @@ namespace ReportMessageFormat { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Rules | * | recommended | false | * ``` */ @@ -506,7 +485,6 @@ namespace RequireMetaDefaultOptions { * | :---------- | :--------- | * | type | suggestion | * | deprecated | false | - * | category | Rules | * | recommended | false | * ``` */ @@ -555,7 +533,6 @@ namespace RequireMetaDocsDescription { * | type | suggestion | * | deprecated | false | * | hasSuggestions | true | - * | category | Rules | * | recommended | false | * ``` */ @@ -601,7 +578,6 @@ namespace RequireMetaDocsRecommended { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Rules | * | recommended | false | * ``` */ @@ -649,7 +625,6 @@ namespace RequireMetaDocsUrl { * | :---------- | :------ | * | type | problem | * | deprecated | false | - * | category | Rules | * | recommended | true | * ``` */ @@ -700,7 +675,6 @@ namespace RequireMetaFixable { * | type | problem | * | deprecated | false | * | fixable | code | - * | category | Rules | * | recommended | true | * ``` */ @@ -718,7 +692,6 @@ namespace RequireMetaHasSuggestions { * | :---------- | :--------- | * | type | suggestion | * | deprecated | false | - * | category | Rules | * | recommended | false | * ``` */ @@ -737,7 +710,6 @@ namespace RequireMetaSchemaDescription { * | type | suggestion | * | deprecated | false | * | hasSuggestions | true | - * | category | Rules | * | recommended | true | * ``` */ @@ -785,7 +757,6 @@ namespace RequireMetaSchema { * | :---------- | :------ | * | type | problem | * | deprecated | false | - * | category | Rules | * | recommended | true | * ``` */ @@ -804,7 +775,6 @@ namespace RequireMetaType { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Tests | * | recommended | false | * ``` */ @@ -844,7 +814,6 @@ namespace TestCasePropertyOrdering { * | type | suggestion | * | deprecated | false | * | fixable | code | - * | category | Tests | * | recommended | false | * ``` */ diff --git a/packages/eslint-configs/src/types/rules/eslint-react-perf-rules.mts b/packages/eslint-configs/src/types/rules/eslint-react-perf-rules.mts index 9aaab93c87..7a7edc6925 100644 --- a/packages/eslint-configs/src/types/rules/eslint-react-perf-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-react-perf-rules.mts @@ -15,7 +15,6 @@ type SpreadOptionsIfIsArray< * | key | value | * | :---------- | :---- | * | deprecated | false | - * | category | | * | recommended | true | * ``` */ @@ -66,7 +65,6 @@ namespace JsxNoNewObjectAsProp { * | key | value | * | :---------- | :---- | * | deprecated | false | - * | category | | * | recommended | true | * ``` */ @@ -117,7 +115,6 @@ namespace JsxNoNewArrayAsProp { * | key | value | * | :---------- | :---- | * | deprecated | false | - * | category | | * | recommended | true | * ``` */ @@ -168,7 +165,6 @@ namespace JsxNoNewFunctionAsProp { * | key | value | * | :---------- | :---- | * | deprecated | false | - * | category | | * | recommended | true | * ``` */ diff --git a/packages/eslint-configs/src/types/rules/eslint-react-rules.mts b/packages/eslint-configs/src/types/rules/eslint-react-rules.mts index 64564eb486..2d8c0e6d23 100644 --- a/packages/eslint-configs/src/types/rules/eslint-react-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-react-rules.mts @@ -14,11 +14,10 @@ type SpreadOptionsIfIsArray< * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/boolean-prop-naming.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace BooleanPropNaming { @@ -77,11 +76,10 @@ namespace BooleanPropNaming { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/button-has-type.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace ButtonHasType { @@ -129,11 +127,10 @@ namespace ButtonHasType { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/checked-requires-onchange-or-readonly.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace CheckedRequiresOnchangeOrReadonly { @@ -173,10 +170,9 @@ namespace CheckedRequiresOnchangeOrReadonly { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/default-props-match-prop-types.md * * ```md - * | key | value | - * | :--------- | :------------- | - * | deprecated | false | - * | category | Best Practices | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace DefaultPropsMatchPropTypes { @@ -215,12 +211,11 @@ namespace DefaultPropsMatchPropTypes { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/destructuring-assignment.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace DestructuringAssignment { @@ -275,11 +270,10 @@ namespace DestructuringAssignment { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/display-name.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DisplayName { @@ -320,11 +314,10 @@ namespace DisplayName { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-component-props.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace ForbidComponentProps { @@ -515,11 +508,10 @@ namespace ForbidComponentProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-dom-props.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace ForbidDomProps { @@ -591,11 +583,10 @@ namespace ForbidDomProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-elements.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace ForbidElements { @@ -660,11 +651,10 @@ namespace ForbidElements { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-foreign-prop-types.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace ForbidForeignPropTypes { @@ -701,11 +691,10 @@ namespace ForbidForeignPropTypes { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-prop-types.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace ForbidPropTypes { @@ -754,13 +743,12 @@ namespace ForbidPropTypes { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forward-ref-uses-ref.md * * ```md - * | key | value | - * | :------------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | false | * ``` */ namespace ForwardRefUsesRef { @@ -773,12 +761,11 @@ namespace ForwardRefUsesRef { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/function-component-definition.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace FunctionComponentDefinition { @@ -867,13 +854,12 @@ namespace FunctionComponentDefinition { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/hook-use-state.md * * ```md - * | key | value | - * | :------------- | :------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | false | * ``` */ namespace HookUseState { @@ -911,11 +897,10 @@ namespace HookUseState { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/iframe-missing-sandbox.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace IframeMissingSandbox { @@ -928,12 +913,11 @@ namespace IframeMissingSandbox { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-boolean-value.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxBooleanValue { @@ -1041,11 +1025,10 @@ namespace JsxBooleanValue { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-child-element-spacing.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxChildElementSpacing { @@ -1058,12 +1041,11 @@ namespace JsxChildElementSpacing { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-closing-bracket-location.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxClosingBracketLocation { @@ -1164,12 +1146,11 @@ namespace JsxClosingBracketLocation { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-closing-tag-location.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | whitespace | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | deprecated | false | + * | fixable | whitespace | + * | recommended | false | * ``` */ namespace JsxClosingTagLocation { @@ -1223,12 +1204,11 @@ namespace JsxClosingTagLocation { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-curly-spacing.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxCurlySpacing { @@ -1368,13 +1348,12 @@ namespace JsxCurlySpacing { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-curly-newline.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | type | layout | - * | deprecated | false | - * | fixable | whitespace | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | layout | + * | deprecated | false | + * | fixable | whitespace | + * | recommended | false | * ``` */ namespace JsxCurlyNewline { @@ -1436,12 +1415,11 @@ namespace JsxCurlyNewline { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-equals-spacing.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxEqualsSpacing { @@ -1473,11 +1451,10 @@ namespace JsxEqualsSpacing { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-filename-extension.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxFilenameExtension { @@ -1528,12 +1505,11 @@ namespace JsxFilenameExtension { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-first-prop-new-line.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxFirstPropNewLine { @@ -1573,11 +1549,10 @@ namespace JsxFirstPropNewLine { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-handler-names.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxHandlerNames { @@ -1749,12 +1724,11 @@ namespace JsxHandlerNames { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-indent.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | whitespace | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | deprecated | false | + * | fixable | whitespace | + * | recommended | false | * ``` */ namespace JsxIndent { @@ -1810,12 +1784,11 @@ namespace JsxIndent { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-indent-props.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxIndentProps { @@ -1883,11 +1856,10 @@ namespace JsxIndentProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-key.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace JsxKey { @@ -1935,11 +1907,10 @@ namespace JsxKey { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-max-depth.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxMaxDepth { @@ -1977,12 +1948,11 @@ namespace JsxMaxDepth { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-max-props-per-line.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxMaxPropsPerLine { @@ -2059,12 +2029,11 @@ namespace JsxMaxPropsPerLine { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-newline.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxNewline { @@ -2124,11 +2093,10 @@ namespace JsxNewline { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-bind.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxNoBind { @@ -2186,11 +2154,10 @@ namespace JsxNoBind { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-comment-textnodes.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace JsxNoCommentTextnodes { @@ -2204,11 +2171,10 @@ namespace JsxNoCommentTextnodes { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-constructed-context-values.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxNoConstructedContextValues { @@ -2221,11 +2187,10 @@ namespace JsxNoConstructedContextValues { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-duplicate-props.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace JsxNoDuplicateProps { @@ -2262,12 +2227,11 @@ namespace JsxNoDuplicateProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-leaked-render.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | fixable | code | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxNoLeakedRender { @@ -2315,11 +2279,10 @@ namespace JsxNoLeakedRender { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-literals.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxNoLiterals { @@ -2412,11 +2375,10 @@ namespace JsxNoLiterals { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-script-url.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxNoScriptUrl { @@ -2518,12 +2480,11 @@ namespace JsxNoScriptUrl { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-target-blank.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace JsxNoTargetBlank { @@ -2581,13 +2542,12 @@ namespace JsxNoTargetBlank { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-useless-fragment.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | fixable | code | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxNoUselessFragment { @@ -2624,12 +2584,11 @@ namespace JsxNoUselessFragment { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-one-expression-per-line.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | whitespace | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | deprecated | false | + * | fixable | whitespace | + * | recommended | false | * ``` */ namespace JsxOneExpressionPerLine { @@ -2674,11 +2633,10 @@ namespace JsxOneExpressionPerLine { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-undef.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace JsxNoUndef { @@ -2716,12 +2674,11 @@ namespace JsxNoUndef { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-curly-brace-presence.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxCurlyBracePresence { @@ -2791,11 +2748,10 @@ namespace JsxCurlyBracePresence { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-pascal-case.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxPascalCase { @@ -2852,12 +2808,11 @@ namespace JsxPascalCase { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-fragments.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxFragments { @@ -2889,12 +2844,11 @@ namespace JsxFragments { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-props-no-multi-spaces.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxPropsNoMultiSpaces { @@ -2907,11 +2861,10 @@ namespace JsxPropsNoMultiSpaces { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-props-no-spreading.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxPropsNoSpreading { @@ -3003,11 +2956,10 @@ namespace JsxPropsNoSpreading { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-props-no-spread-multi.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace JsxPropsNoSpreadMulti { @@ -3020,11 +2972,10 @@ namespace JsxPropsNoSpreadMulti { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-sort-default-props.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | true | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | true | + * | recommended | false | * ``` */ namespace JsxSortDefaultProps { @@ -3054,12 +3005,11 @@ namespace JsxSortDefaultProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-sort-props.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxSortProps { @@ -3133,12 +3083,11 @@ namespace JsxSortProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-space-before-closing.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | true | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | true | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxSpaceBeforeClosing { @@ -3165,12 +3114,11 @@ namespace JsxSpaceBeforeClosing { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-tag-spacing.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | whitespace | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :--------- | + * | deprecated | false | + * | fixable | whitespace | + * | recommended | false | * ``` */ namespace JsxTagSpacing { @@ -3252,11 +3200,10 @@ namespace JsxTagSpacing { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-uses-react.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace JsxUsesReact { @@ -3269,11 +3216,10 @@ namespace JsxUsesReact { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-uses-vars.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace JsxUsesVars { @@ -3286,12 +3232,11 @@ namespace JsxUsesVars { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-wrap-multilines.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace JsxWrapMultilines { @@ -3443,12 +3388,11 @@ namespace JsxWrapMultilines { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-invalid-html-attribute.md * * ```md - * | key | value | - * | :------------- | :-------------- | - * | type | suggestion | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Possible Errors | + * | key | value | + * | :------------- | :--------- | + * | type | suggestion | + * | deprecated | false | + * | hasSuggestions | true | * ``` */ namespace NoInvalidHtmlAttribute { @@ -3483,11 +3427,10 @@ namespace NoInvalidHtmlAttribute { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-access-state-in-setstate.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoAccessStateInSetstate { @@ -3500,11 +3443,10 @@ namespace NoAccessStateInSetstate { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-adjacent-inline-elements.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoAdjacentInlineElements { @@ -3517,11 +3459,10 @@ namespace NoAdjacentInlineElements { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-array-index-key.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoArrayIndexKey { @@ -3534,12 +3475,11 @@ namespace NoArrayIndexKey { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-arrow-function-lifecycle.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | fixable | code | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace NoArrowFunctionLifecycle { @@ -3552,11 +3492,10 @@ namespace NoArrowFunctionLifecycle { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-children-prop.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoChildrenProp { @@ -3594,11 +3533,10 @@ namespace NoChildrenProp { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-danger.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoDanger { @@ -3642,11 +3580,10 @@ namespace NoDanger { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-danger-with-children.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoDangerWithChildren { @@ -3659,11 +3596,10 @@ namespace NoDangerWithChildren { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-deprecated.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoDeprecated { @@ -3676,11 +3612,10 @@ namespace NoDeprecated { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-did-mount-set-state.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoDidMountSetState { @@ -3711,11 +3646,10 @@ namespace NoDidMountSetState { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-did-update-set-state.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoDidUpdateSetState { @@ -3746,11 +3680,10 @@ namespace NoDidUpdateSetState { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-direct-mutation-state.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoDirectMutationState { @@ -3763,11 +3696,10 @@ namespace NoDirectMutationState { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-find-dom-node.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoFindDomNode { @@ -3780,11 +3712,10 @@ namespace NoFindDomNode { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-is-mounted.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoIsMounted { @@ -3797,11 +3728,10 @@ namespace NoIsMounted { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-multi-comp.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoMultiComp { @@ -3839,11 +3769,10 @@ namespace NoMultiComp { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-namespace.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoNamespace { @@ -3856,11 +3785,10 @@ namespace NoNamespace { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-set-state.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoSetState { @@ -3873,11 +3801,10 @@ namespace NoSetState { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-string-refs.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoStringRefs { @@ -3914,11 +3841,10 @@ namespace NoStringRefs { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-redundant-should-component-update.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoRedundantShouldComponentUpdate { @@ -3931,11 +3857,10 @@ namespace NoRedundantShouldComponentUpdate { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-render-return-value.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace NoRenderReturnValue { @@ -3948,11 +3873,10 @@ namespace NoRenderReturnValue { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-this-in-sfc.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoThisInSfc { @@ -3965,11 +3889,10 @@ namespace NoThisInSfc { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-typos.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoTypos { @@ -3982,12 +3905,11 @@ namespace NoTypos { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unescaped-entities.md * * ```md - * | key | value | - * | :------------- | :-------------- | - * | deprecated | false | - * | hasSuggestions | true | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :------------- | :---- | + * | deprecated | false | + * | hasSuggestions | true | + * | recommended | true | * ``` */ namespace NoUnescapedEntities { @@ -4053,12 +3975,11 @@ namespace NoUnescapedEntities { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unknown-property.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | fixable | code | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | true | * ``` */ namespace NoUnknownProperty { @@ -4103,11 +4024,10 @@ namespace NoUnknownProperty { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unsafe.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoUnsafe { @@ -4145,11 +4065,10 @@ namespace NoUnsafe { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unstable-nested-components.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoUnstableNestedComponents { @@ -4197,11 +4116,10 @@ namespace NoUnstableNestedComponents { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unused-class-component-methods.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoUnusedClassComponentMethods { @@ -4214,11 +4132,10 @@ namespace NoUnusedClassComponentMethods { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unused-prop-types.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoUnusedPropTypes { @@ -4270,11 +4187,10 @@ namespace NoUnusedPropTypes { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unused-state.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoUnusedState { @@ -4288,11 +4204,10 @@ namespace NoUnusedState { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-object-type-as-default-prop.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoObjectTypeAsDefaultProp { @@ -4305,11 +4220,10 @@ namespace NoObjectTypeAsDefaultProp { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-will-update-set-state.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace NoWillUpdateSetState { @@ -4340,11 +4254,10 @@ namespace NoWillUpdateSetState { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-es6-class.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace PreferEs6Class { @@ -4376,11 +4289,10 @@ namespace PreferEs6Class { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-exact-props.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace PreferExactProps { @@ -4393,12 +4305,11 @@ namespace PreferExactProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-read-only-props.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace PreferReadOnlyProps { @@ -4411,11 +4322,10 @@ namespace PreferReadOnlyProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-stateless-function.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace PreferStatelessFunction { @@ -4453,11 +4363,10 @@ namespace PreferStatelessFunction { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prop-types.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace PropTypes { @@ -4508,11 +4417,10 @@ namespace PropTypes { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/react-in-jsx-scope.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace ReactInJsxScope { @@ -4525,10 +4433,9 @@ namespace ReactInJsxScope { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/require-default-props.md * * ```md - * | key | value | - * | :--------- | :------------- | - * | deprecated | false | - * | category | Best Practices | + * | key | value | + * | :--------- | :---- | + * | deprecated | false | * ``` */ namespace RequireDefaultProps { @@ -4584,11 +4491,10 @@ namespace RequireDefaultProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/require-optimization.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace RequireOptimization { @@ -4628,11 +4534,10 @@ namespace RequireOptimization { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/require-render-return.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | true | * ``` */ namespace RequireRenderReturn { @@ -4645,12 +4550,11 @@ namespace RequireRenderReturn { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/self-closing-comp.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace SelfClosingComp { @@ -4693,11 +4597,10 @@ namespace SelfClosingComp { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-comp.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace SortComp { @@ -4749,11 +4652,10 @@ namespace SortComp { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-default-props.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace SortDefaultProps { @@ -4790,12 +4692,11 @@ namespace SortDefaultProps { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-prop-types.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | fixable | code | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | fixable | code | + * | recommended | false | * ``` */ namespace SortPropTypes { @@ -4852,11 +4753,10 @@ namespace SortPropTypes { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/state-in-constructor.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace StateInConstructor { @@ -4888,11 +4788,10 @@ namespace StateInConstructor { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/static-property-placement.md * * ```md - * | key | value | - * | :---------- | :--------------- | - * | deprecated | false | - * | category | Stylistic Issues | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace StaticPropertyPlacement { @@ -5004,11 +4903,10 @@ namespace StaticPropertyPlacement { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/style-prop-object.md * * ```md - * | key | value | - * | :---------- | :-------------- | - * | deprecated | false | - * | category | Possible Errors | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace StylePropObject { @@ -5050,11 +4948,10 @@ namespace StylePropObject { * @link https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/void-dom-elements-no-children.md * * ```md - * | key | value | - * | :---------- | :------------- | - * | deprecated | false | - * | category | Best Practices | - * | recommended | false | + * | key | value | + * | :---------- | :---- | + * | deprecated | false | + * | recommended | false | * ``` */ namespace VoidDomElementsNoChildren { diff --git a/packages/eslint-configs/src/types/rules/eslint-security-rules.mts b/packages/eslint-configs/src/types/rules/eslint-security-rules.mts index 6a7276fbeb..9577ee6214 100644 --- a/packages/eslint-configs/src/types/rules/eslint-security-rules.mts +++ b/packages/eslint-configs/src/types/rules/eslint-security-rules.mts @@ -8,12 +8,11 @@ import { type Linter } from 'eslint'; * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-unsafe-regex.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectUnsafeRegex { @@ -27,12 +26,11 @@ namespace DetectUnsafeRegex { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-non-literal-regexp.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectNonLiteralRegexp { @@ -46,12 +44,11 @@ namespace DetectNonLiteralRegexp { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-non-literal-require.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectNonLiteralRequire { @@ -65,12 +62,11 @@ namespace DetectNonLiteralRequire { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-non-literal-fs-filename.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectNonLiteralFsFilename { @@ -84,12 +80,11 @@ namespace DetectNonLiteralFsFilename { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-eval-with-expression.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectEvalWithExpression { @@ -103,12 +98,11 @@ namespace DetectEvalWithExpression { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-pseudoRandomBytes.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectPseudoRandomBytes { @@ -122,12 +116,11 @@ namespace DetectPseudoRandomBytes { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-possible-timing-attacks.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectPossibleTimingAttacks { @@ -140,12 +133,11 @@ namespace DetectPossibleTimingAttacks { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-no-csrf-before-method-override.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectNoCsrfBeforeMethodOverride { @@ -158,12 +150,11 @@ namespace DetectNoCsrfBeforeMethodOverride { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-buffer-noassert.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectBufferNoassert { @@ -176,12 +167,11 @@ namespace DetectBufferNoassert { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-child-process.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectChildProcess { @@ -195,12 +185,11 @@ namespace DetectChildProcess { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-disable-mustache-escape.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectDisableMustacheEscape { @@ -213,12 +202,11 @@ namespace DetectDisableMustacheEscape { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-object-injection.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectObjectInjection { @@ -232,12 +220,11 @@ namespace DetectObjectInjection { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-new-buffer.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectNewBuffer { @@ -251,12 +238,11 @@ namespace DetectNewBuffer { * @link https://github.com/eslint-community/eslint-plugin-security/blob/main/docs/rules/detect-bidi-characters.md * * ```md - * | key | value | - * | :---------- | :------------------------------ | - * | type | error | - * | deprecated | false | - * | category | Possible Security Vulnerability | - * | recommended | true | + * | key | value | + * | :---------- | :---- | + * | type | error | + * | deprecated | false | + * | recommended | true | * ``` */ namespace DetectBidiCharacters { From bfb4167e020349dd1c4e1c2f5ffa27621e659a19 Mon Sep 17 00:00:00 2001 From: noshiro-pf Date: Sun, 23 Feb 2025 03:58:21 +0900 Subject: [PATCH 23/25] refactor: fix eslint errors --- .../balloon/decided-answer-balloon.tsx | 36 +-- .../algo-app/src/components/bp/spinner.tsx | 2 +- .../algo-app/src/components/card/card.tsx | 26 +- .../src/components/card/cards-sub/card-0.tsx | 12 +- .../src/components/card/cards-sub/card-1.tsx | 2 +- .../src/components/card/cards-sub/card-10.tsx | 14 +- .../src/components/card/cards-sub/card-11.tsx | 4 +- .../src/components/card/cards-sub/card-2.tsx | 10 +- .../src/components/card/cards-sub/card-3.tsx | 10 +- .../src/components/card/cards-sub/card-4.tsx | 2 +- .../src/components/card/cards-sub/card-5.tsx | 10 +- .../src/components/card/cards-sub/card-6.tsx | 6 +- .../src/components/card/cards-sub/card-7.tsx | 2 +- .../src/components/card/cards-sub/card-8.tsx | 8 +- .../src/components/card/cards-sub/card-9.tsx | 6 +- .../src/components/create-room-page.tsx | 6 +- .../algo-app/src/components/game-main.tsx | 2 +- .../src/components/join-room-page.tsx | 6 +- .../organisms/turn-player-highlighter.tsx | 15 +- .../src/components/input-group-view.tsx | 2 +- .../src/components/numeric-input-view.tsx | 36 +-- .../cant-stop-probability-app/src/app.tsx | 4 +- .../src/components/dicer-number.tsx | 45 ++-- .../src/components/main-view.tsx | 12 +- .../src/components/atoms/color-item.tsx | 27 ++- .../molecules/division-number-slider.tsx | 2 +- .../components/molecules/first-hue-slider.tsx | 2 +- .../molecules/saturation-lightness-slider.tsx | 4 +- .../src/components/organisms/color-list.tsx | 53 +++-- .../colored-distribution-selected.tsx | 72 +++--- .../organisms/colored-distribution.tsx | 69 +++--- .../luminance-visualizer-view.tsx | 14 +- .../pages/text-color-contrast-table.tsx | 202 +++++++++------- .../src/components/atoms/description.tsx | 31 ++- .../src/components/atoms/icons/calendar.tsx | 32 +-- .../src/components/atoms/icons/circle.tsx | 8 +- .../src/components/atoms/icons/close.tsx | 8 +- .../src/components/atoms/icons/comment.tsx | 14 +- .../src/components/atoms/icons/delete.tsx | 14 +- .../src/components/atoms/icons/edit.tsx | 8 +- .../components/atoms/icons/google-icon.tsx | 106 ++++----- .../src/components/atoms/icons/triangle.tsx | 18 +- .../atoms/required-participant-icon.tsx | 2 +- .../molecules/add-element-button.tsx | 2 +- .../molecules/custom-icon-button.tsx | 29 ++- .../multiple-date-picker/date-picker-day.tsx | 2 +- .../multiple-date-picker.tsx | 6 +- .../components/multiple-date-picker/week.tsx | 2 +- .../multiple-date-picker/weekdays-header.tsx | 4 +- .../answer-being-edited.tsx | 36 +-- .../organisms/answer-table/answer-table.tsx | 6 +- .../organisms/answer-table/comment-button.tsx | 55 +++-- .../filter-by-icon-popover.tsx | 35 ++- .../organisms/answer-table/sort-button.tsx | 25 +- .../organisms/confirm-email-dialog.tsx | 18 +- .../components/organisms/event-settings.tsx | 61 +++-- .../src/components/organisms/navbar.tsx | 86 +++---- .../organisms/notification-settings.tsx | 2 +- .../set-times-popover-content.tsx | 6 +- .../set-times-popover/set-times-popover.tsx | 23 +- .../delete-account-dialog-google.tsx | 93 +++++--- .../delete-account-dialog.tsx | 142 ++++++----- .../update-display-name-dialog.tsx | 89 ++++--- .../update-email-dialog.tsx | 149 +++++++----- .../update-password-dialog.tsx | 222 +++++++++++------- .../pages/answer-page/answer-page.tsx | 20 +- .../src/components/pages/not-found-page.tsx | 32 ++- .../src/components/pages/register-page.tsx | 32 ++- .../components/pages/reset-password-page.tsx | 4 +- .../src/components/pages/sign-in-page.tsx | 26 +- .../src/components/pages/ui-parts-test.tsx | 19 +- .../src/error-handler/error-boundary.tsx | 4 +- .../repayment-type-radio-group.tsx | 4 +- .../src/components/mui/mui-tabs.tsx | 21 +- .../components/writings/writings-element.tsx | 2 +- .../apps/template-preact-app-vite/src/app.tsx | 16 +- .../apps/template-react-app-vite/src/app.tsx | 18 +- .../src/components/view/checkbox-view.tsx | 2 +- .../src/components/view/input-view.tsx | 4 +- .../components/view/numeric-input-view.tsx | 36 +-- .../wrapper/bp-email-input-group.tsx | 49 ++-- .../components/wrapper/bp-password-input.tsx | 20 +- .../react-mui-utils/src/confirm-dialog.tsx | 4 +- .../utils/react-mui-utils/src/mui-slider.tsx | 2 +- packages/utils/react-mui-utils/src/tabs.tsx | 4 +- .../src/centering-wrapper.tsx | 26 +- 86 files changed, 1362 insertions(+), 1040 deletions(-) diff --git a/packages/apps/algo-app/src/components/balloon/decided-answer-balloon.tsx b/packages/apps/algo-app/src/components/balloon/decided-answer-balloon.tsx index 02a3c13b00..ea1041d53c 100644 --- a/packages/apps/algo-app/src/components/balloon/decided-answer-balloon.tsx +++ b/packages/apps/algo-app/src/components/balloon/decided-answer-balloon.tsx @@ -77,38 +77,38 @@ export const DecidedAnswerBalloon = memoNamed( - + diff --git a/packages/apps/algo-app/src/components/bp/spinner.tsx b/packages/apps/algo-app/src/components/bp/spinner.tsx index 7ea2acf034..d04e7a3bf2 100644 --- a/packages/apps/algo-app/src/components/bp/spinner.tsx +++ b/packages/apps/algo-app/src/components/bp/spinner.tsx @@ -59,7 +59,7 @@ export const Spinner = memoNamed('Spinner', ({ size: _size, value }) => { // - SPINNER_ANIMATION isolates svg from parent display and is always centered inside root element. return ( // eslint-disable-next-line jsx-a11y/prefer-tag-over-role - + ( onMouseLeave={onMouseLeave} > ( visibilityFromMe === 'faceDownButVisibleToMe' ? ( <> @@ -155,10 +155,10 @@ export const CardComponent = memoNamed( ( <> - + - + )); diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-1.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-1.tsx index e63da61d3b..618663e606 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-1.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-1.tsx @@ -2,7 +2,7 @@ import { type CardProps } from './card-props'; export const Card1 = memoNamed('Card1', ({ textColor }: CardProps) => ( )); diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-10.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-10.tsx index ac275cf222..97ed52ca12 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-10.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-10.tsx @@ -3,25 +3,25 @@ import { type CardProps } from './card-props'; export const Card10 = memoNamed('Card10', ({ color, textColor }: CardProps) => ( <> - + - + diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-11.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-11.tsx index d8c9bc9bb6..419bdcc17c 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-11.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-11.tsx @@ -3,11 +3,11 @@ import { type CardProps } from './card-props'; export const Card11 = memoNamed('Card11', ({ textColor }: CardProps) => ( <> diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-2.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-2.tsx index e0be54c9ad..744ffbd430 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-2.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-2.tsx @@ -3,23 +3,23 @@ import { type CardProps } from './card-props'; export const Card2 = memoNamed('Card2', ({ textColor }: CardProps) => ( <> diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-3.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-3.tsx index c2a2170f4a..af93c0e48a 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-3.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-3.tsx @@ -3,20 +3,20 @@ import { type CardProps } from './card-props'; export const Card3 = memoNamed('Card3', ({ color, textColor }: CardProps) => ( <> - + diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-4.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-4.tsx index 856d9c3f12..b5c6cd8716 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-4.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-4.tsx @@ -2,7 +2,7 @@ import { type CardProps } from './card-props'; export const Card4 = memoNamed('Card4', ({ textColor }: CardProps) => ( )); diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-5.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-5.tsx index c5a462e44a..0955447f45 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-5.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-5.tsx @@ -2,15 +2,15 @@ import { type CardProps } from './card-props'; export const Card5 = memoNamed('Card5', ({ color, textColor }: CardProps) => ( <> - + - - + + diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-6.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-6.tsx index 0bef612fe1..28a8779550 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-6.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-6.tsx @@ -3,10 +3,10 @@ import { type CardProps } from './card-props'; export const Card6 = memoNamed('Card6', ({ color, textColor }: CardProps) => ( <> - - + + )); diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-7.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-7.tsx index db9e511447..26bb0d19b2 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-7.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-7.tsx @@ -2,7 +2,7 @@ import { type CardProps } from './card-props'; export const Card7 = memoNamed('Card7', ({ textColor }: CardProps) => ( )); diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-8.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-8.tsx index 4b609f245b..9b046d4da2 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-8.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-8.tsx @@ -2,12 +2,12 @@ import { type CardProps } from './card-props'; export const Card8 = memoNamed('Card8', ({ color, textColor }: CardProps) => ( <> - + - - + + )); diff --git a/packages/apps/algo-app/src/components/card/cards-sub/card-9.tsx b/packages/apps/algo-app/src/components/card/cards-sub/card-9.tsx index 96413c1dc6..5c81e4bd5d 100644 --- a/packages/apps/algo-app/src/components/card/cards-sub/card-9.tsx +++ b/packages/apps/algo-app/src/components/card/cards-sub/card-9.tsx @@ -2,10 +2,10 @@ import { type CardProps } from './card-props'; export const Card9 = memoNamed('Card9', ({ color, textColor }: CardProps) => ( <> - - + + diff --git a/packages/apps/algo-app/src/components/create-room-page.tsx b/packages/apps/algo-app/src/components/create-room-page.tsx index 5d94f42a26..26b6704315 100644 --- a/packages/apps/algo-app/src/components/create-room-page.tsx +++ b/packages/apps/algo-app/src/components/create-room-page.tsx @@ -40,7 +40,7 @@ export const CreateRoomPage = memoNamed('CreateRoomPage', () => { @@ -50,7 +50,7 @@ export const CreateRoomPage = memoNamed('CreateRoomPage', () => { @@ -58,7 +58,7 @@ export const CreateRoomPage = memoNamed('CreateRoomPage', () => { diff --git a/packages/apps/algo-app/src/components/game-main.tsx b/packages/apps/algo-app/src/components/game-main.tsx index b9f9087647..dd8c8fb0b2 100644 --- a/packages/apps/algo-app/src/components/game-main.tsx +++ b/packages/apps/algo-app/src/components/game-main.tsx @@ -68,7 +68,7 @@ export const GameMain = memoNamed('GameMain', ({ windowSize }) => { {dictionary.gameMain.endTurnButton} diff --git a/packages/apps/algo-app/src/components/join-room-page.tsx b/packages/apps/algo-app/src/components/join-room-page.tsx index 90d4951bf7..4b25855881 100644 --- a/packages/apps/algo-app/src/components/join-room-page.tsx +++ b/packages/apps/algo-app/src/components/join-room-page.tsx @@ -56,7 +56,7 @@ export const JoinRoomPage = memoNamed('JoinRoomPage', ({ roomId }) => { @@ -70,7 +70,7 @@ export const JoinRoomPage = memoNamed('JoinRoomPage', ({ roomId }) => { @@ -78,7 +78,7 @@ export const JoinRoomPage = memoNamed('JoinRoomPage', ({ roomId }) => { {loading ? : {dc.button}} diff --git a/packages/apps/algo-app/src/components/organisms/turn-player-highlighter.tsx b/packages/apps/algo-app/src/components/organisms/turn-player-highlighter.tsx index fee821c701..4cbe761dc2 100644 --- a/packages/apps/algo-app/src/components/organisms/turn-player-highlighter.tsx +++ b/packages/apps/algo-app/src/components/organisms/turn-player-highlighter.tsx @@ -7,16 +7,19 @@ type Props = Readonly<{ export const TurnPlayerHighlighter = memoNamed( 'TurnPlayerHighlighter', - ({ position }) => ( - { + const style = useMemo( + () => ({ top: `${position.top - playerNameRectPadding}px`, left: `${position.left - playerNameRectPadding}px`, width: `${position.width + 2 * playerNameRectPadding}px`, height: `${position.height + 2 * playerNameRectPadding}px`, - }} - /> - ), + }), + [position.height, position.left, position.top, position.width], + ); + + return ; + }, ); const Rectangle = styled('div')` diff --git a/packages/apps/blueprintjs-playground-styled/src/components/input-group-view.tsx b/packages/apps/blueprintjs-playground-styled/src/components/input-group-view.tsx index d0808ea4b3..3c261b243a 100644 --- a/packages/apps/blueprintjs-playground-styled/src/components/input-group-view.tsx +++ b/packages/apps/blueprintjs-playground-styled/src/components/input-group-view.tsx @@ -29,7 +29,7 @@ export const InputGroupView = memoNamed( `} disabled={disabled} placeholder={placeholder} - type='text' + type={"text"} value={value} onChange={onChange} /> diff --git a/packages/apps/blueprintjs-playground-styled/src/components/numeric-input-view.tsx b/packages/apps/blueprintjs-playground-styled/src/components/numeric-input-view.tsx index e91ddae614..5486a80f20 100644 --- a/packages/apps/blueprintjs-playground-styled/src/components/numeric-input-view.tsx +++ b/packages/apps/blueprintjs-playground-styled/src/components/numeric-input-view.tsx @@ -61,40 +61,40 @@ export const NumericInputView = memoNamed( `} >
    - -
    - } + + + + + ), + [onSortAscClick, onSortDescClick], + ); + return ( - - - - } + content={popoverContent} isOpen={isOpen} placement={'bottom'} onClose={handleClose} diff --git a/packages/apps/event-schedule-app/src/components/organisms/confirm-email-dialog.tsx b/packages/apps/event-schedule-app/src/components/organisms/confirm-email-dialog.tsx index 18314382ca..65cc5c9830 100644 --- a/packages/apps/event-schedule-app/src/components/organisms/confirm-email-dialog.tsx +++ b/packages/apps/event-schedule-app/src/components/organisms/confirm-email-dialog.tsx @@ -45,7 +45,7 @@ export const ConfirmEmailDialog = memoNamed( ( // eslint-disable-next-line jsx-a11y/no-autofocus autoFocus={true} intent={state.emailFormIntent} - rightElement={ - + ), + [enterButtonDisabled, isWaitingResponse], + ); + + return ( + - {dc.button.deleteAccount} - - } + submitButton={submitButton} title={dc.deleteAccount.title} /> ); }, ); + +const verifyEmailInputLabel = ; diff --git a/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/delete-account-dialog.tsx b/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/delete-account-dialog.tsx index ef62484f68..fc348270d7 100644 --- a/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/delete-account-dialog.tsx +++ b/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/delete-account-dialog.tsx @@ -25,71 +25,99 @@ export const DeleteAccountDialog = memoNamed( passwordIsOpen, } = useObservableValue(DeleteAccountPageStore.state); - return ( - ( + + ), + [formState.isWaitingResponse, passwordIsOpen], + ); + + const body = useMemo( + () => ( +
    + - {dc.deleteAccount.verifyEmail}} - > - - - + + + {dc.reauthenticate.password}} - > - - } - type={passwordIsOpen ? 'text' : 'password'} - value={formState.password.inputValue} - onValueChange={DeleteAccountPageStore.inputPasswordHandler} - /> - -
    - } + rightElement={passwordLockButton} + type={passwordIsOpen ? 'text' : 'password'} + value={formState.password.inputValue} + onValueChange={DeleteAccountPageStore.inputPasswordHandler} + /> + + + ), + [ + emailFormIntent, + formState.email.error, + formState.email.inputValue, + formState.isWaitingResponse, + formState.password.error, + formState.password.inputValue, + passwordFormIntent, + passwordIsOpen, + passwordLockButton, + ], + ); + + const submitButton = useMemo( + () => ( + + ), + [enterButtonDisabled, formState.isWaitingResponse], + ); + + return ( + - {dc.button.deleteAccount} - - } + submitButton={submitButton} title={dc.deleteAccount.title} /> ); }, ); + +const passwordInputLabel = ; +const verifyEmailInputLabel = ; diff --git a/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-display-name-dialog.tsx b/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-display-name-dialog.tsx index 7553178f1a..3864df0740 100644 --- a/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-display-name-dialog.tsx +++ b/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-display-name-dialog.tsx @@ -19,49 +19,66 @@ export const UpdateDisplayNameDialog = memoNamed( const { formState, displayNameFormIntent, enterButtonDisabled } = useObservableValue(UpdateDisplayNamePageStore.state); - return ( - ( +
    + - {dc.updateDisplayName.newDisplayName}} - > - - -
    - } + type={'text'} + value={formState.displayName.inputValue} + onValueChange={UpdateDisplayNamePageStore.inputDisplayNameHandler} + /> + + + ), + [ + displayNameFormIntent, + formState.displayName.error, + formState.displayName.inputValue, + formState.isWaitingResponse, + ], + ); + + const submitButton = useMemo( + () => ( + + ), + [enterButtonDisabled, formState.isWaitingResponse], + ); + + return ( + - {dc.button.update} - - } + submitButton={submitButton} title={dc.updateDisplayName.title} /> ); }, ); + +const newDisplayNameInputLabel = ( + +); diff --git a/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-email-dialog.tsx b/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-email-dialog.tsx index acf7034744..263ca4e044 100644 --- a/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-email-dialog.tsx +++ b/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-email-dialog.tsx @@ -26,75 +26,102 @@ export const UpdateEmailDialog = memoNamed( passwordIsOpen, } = useObservableValue(UpdateEmailPageStore.state); - return ( - ( + + ), + [formState.isWaitingResponse, passwordIsOpen], + ); + + const body = useMemo( + () => ( +
    + +
    {currentEmail ?? ''}
    +     + - {dc.updateEmail.currentEmail}} - > -
    {currentEmail ?? ''}
    -     - {dc.updateEmail.newEmail}} - > - - - + + + {dc.reauthenticate.password}} - > - - } - type={passwordIsOpen ? 'text' : 'password'} - value={formState.password.inputValue} - onValueChange={UpdateEmailPageStore.inputPasswordHandler} - /> - -
    - } + rightElement={passwordLockButton} + type={passwordIsOpen ? 'text' : 'password'} + value={formState.password.inputValue} + onValueChange={UpdateEmailPageStore.inputPasswordHandler} + /> + + + ), + [ + currentEmail, + emailFormIntent, + formState.email.error, + formState.email.inputValue, + formState.isWaitingResponse, + formState.password.error, + formState.password.inputValue, + passwordFormIntent, + passwordIsOpen, + passwordLockButton, + ], + ); + + const submitButton = useMemo( + () => ( + + ), + [enterButtonDisabled, formState.isWaitingResponse], + ); + + return ( + - {dc.button.update} - - } + submitButton={submitButton} title={dc.updateEmail.title} /> ); }, ); + +const passwordInputLabel = ; +const currentEmailInputLabel = ; +const newEmailInputLabel = ; diff --git a/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-password-dialog.tsx b/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-password-dialog.tsx index 5a1cca9b02..149f1d7447 100644 --- a/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-password-dialog.tsx +++ b/packages/apps/event-schedule-app/src/components/organisms/update-user-info-dialog/update-password-dialog.tsx @@ -30,109 +30,151 @@ export const UpdatePasswordDialog = memoNamed( newPasswordIsOpen, } = useObservableValue(UpdatePasswordPageStore.state); - return ( - ( + + ), + [formState.isWaitingResponse, newPasswordIsOpen], + ); + + const oldPasswordInputButton = useMemo( + () => ( + + ), + [formState.isWaitingResponse, oldPasswordIsOpen], + ); + + const body = useMemo( + () => ( +
    + - {dc.updatePassword.currentEmail}} - style={hideStyle} - > - - + type={'email'} + value={currentEmail ?? ''} + onValueChange={noop} + /> + - + {dc.updatePassword.oldPassword}} - > - - } - type={oldPasswordIsOpen ? 'text' : 'password'} - value={formState.oldPassword.inputValue} - onValueChange={UpdatePasswordPageStore.inputOldPasswordHandler} - /> - + rightElement={oldPasswordInputButton} + type={oldPasswordIsOpen ? 'text' : 'password'} + value={formState.oldPassword.inputValue} + onValueChange={UpdatePasswordPageStore.inputOldPasswordHandler} + /> + - + {dc.updatePassword.newPassword}} - > - - + type={'password'} + value={formState.newPassword.password.inputValue} + onValueChange={UpdatePasswordPageStore.inputNewPasswordHandler} + /> + - + {dc.updatePassword.verifyNewPassword}} - > - - } - type={newPasswordIsOpen ? 'text' : 'password'} - value={formState.newPassword.passwordConfirmation.inputValue} - onValueChange={ - UpdatePasswordPageStore.inputNewPasswordConfirmationHandler - } - /> - -
    - } + rightElement={newPasswordLockButton} + type={newPasswordIsOpen ? 'text' : 'password'} + value={formState.newPassword.passwordConfirmation.inputValue} + onValueChange={ + UpdatePasswordPageStore.inputNewPasswordConfirmationHandler + } + /> + + + ), + [ + currentEmail, + formState.isWaitingResponse, + formState.newPassword.password.error, + formState.newPassword.password.inputValue, + formState.newPassword.passwordConfirmation.error, + formState.newPassword.passwordConfirmation.inputValue, + formState.oldPassword.error, + formState.oldPassword.inputValue, + newPasswordFormIntent, + newPasswordIsOpen, + newPasswordLockButton, + oldPasswordFormIntent, + oldPasswordInputButton, + oldPasswordIsOpen, + ], + ); + + const submitButton = useMemo( + () => ( + + ), + [enterButtonDisabled, formState.isWaitingResponse], + ); + + return ( + - {dc.button.update} - - } + submitButton={submitButton} title={dc.updatePassword.title} /> ); }, ); + +const oldPasswordInputLabel = ; +const currentEmailInputLabel = ; +const newPasswordInputLabel = ; +const verifyNewPasswordInputLabel = ( + +); diff --git a/packages/apps/event-schedule-app/src/components/pages/answer-page/answer-page.tsx b/packages/apps/event-schedule-app/src/components/pages/answer-page/answer-page.tsx index a1d58efeae..d2426ce5bd 100644 --- a/packages/apps/event-schedule-app/src/components/pages/answer-page/answer-page.tsx +++ b/packages/apps/event-schedule-app/src/components/pages/answer-page/answer-page.tsx @@ -240,13 +240,7 @@ export const AnswerPage = memoNamed('AnswerPage', () => { addOnBlur={false} addOnPaste={false} leftIcon={'filter-list'} - rightElement={ -