// パーサーの役割
 
// TypeScript コード
const greeting: string = "Hello";
 
// TypeScript Compiler AST (TSC)
{
  kind: SyntaxKind.VariableDeclaration,
  name: { text: "greeting" },
  type: { kind: SyntaxKind.StringKeyword }
}
 
// ESTree 形式 (ESLint が理解できる形式)
{
  type: "VariableDeclaration",
  declarations: [{
    id: { type: "Identifier", name: "greeting" },
    typeAnnotation: { type: "TSStringKeyword" }
  }]
}

// プラグインが提供するルールの例
{
  rules: {
    "@typescript-eslint/no-explicit-any": "error",           // any 禁止
    "@typescript-eslint/no-floating-promises": "error",      // Promise 放置検出
    "@typescript-eslint/switch-exhaustiveness-check": "error" // switch 網羅性
  }
}

// v8 以降の推奨インストール
npm install -D eslint typescript-eslint
 
// v7 以前 (legacy)
npm install -D eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin

// 型情報を使うルールの例
 
// no-floating-promises ルールの内部動作イメージ
function checkNode(node: TSESTree.Node) {
  // 1. ノードの型情報を取得
  const type = checker.getTypeAtLocation(node);
 
  // 2. Promise 型かどうかをチェック
  if (isPromiseType(type)) {
    // 3. await または .catch() がついているかチェック
    if (!isHandled(node)) {
      context.report({
        node,
        messageId: "floatingPromise"
      });
    }
  }
}

// 型情報ルールで検出できる問題
 
// 問題1: Promise の放置
async function fetchData() {
  fetch("/api/data"); // ← no-floating-promises が警告
}
 
// 問題2: 型安全でない操作
function process(value: unknown) {
  value.method(); // ← no-unsafe-call が警告
}
 
// 問題3: async 関数の誤用
[1, 2, 3].forEach(async (n) => { // ← no-misused-promises が警告
  await processNumber(n);
});

// Flat Config の構造
export default [
  // 各要素は ConfigObject
  {
    files: ["**/*.ts"],           // 対象ファイル
    languageOptions: { /* ... */ }, // パーサー設定
    plugins: { /* ... */ },       // プラグイン
    rules: { /* ... */ }          // ルール
  },
  {
    ignores: ["dist/**"]          // 除外パターン
  }
];

# 最小構成
npm install -D eslint typescript-eslint
 
# Prettier 連携を含む構成
npm install -D eslint typescript-eslint eslint-config-prettier
 
# React プロジェクト
npm install -D eslint typescript-eslint \
  eslint-plugin-react-hooks eslint-plugin-react-refresh
 
# Node.js プロジェクト
npm install -D eslint typescript-eslint \
  eslint-plugin-node eslint-plugin-security

// eslint.config.ts (最小構成)
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
 
export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.recommended
);

// eslint.config.ts (型情報を使う構成)
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
 
export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.recommendedTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  }
);

// eslint.config.ts (本格的な構成)
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
import prettierConfig from "eslint-config-prettier";
 
export default tseslint.config(
  // 1. 基本ルール
  eslint.configs.recommended,
 
  // 2. TypeScript ルール (strict + stylistic)
  ...tseslint.configs.strictTypeChecked,
  ...tseslint.configs.stylisticTypeChecked,
 
  // 3. パーサー設定
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  },
 
  // 4. カスタムルール
  {
    rules: {
      // async 関連
      "@typescript-eslint/no-floating-promises": "error",
      "@typescript-eslint/no-misused-promises": "error",
      "@typescript-eslint/await-thenable": "error",
      "@typescript-eslint/return-await": ["error", "in-try-catch"],
 
      // 型安全性
      "@typescript-eslint/no-explicit-any": "error",
      "@typescript-eslint/no-unsafe-assignment": "error",
      "@typescript-eslint/no-unsafe-call": "error",
      "@typescript-eslint/no-unsafe-member-access": "error",
      "@typescript-eslint/no-unsafe-return": "error",
 
      // インポート
      "@typescript-eslint/consistent-type-imports": [
        "error",
        { prefer: "type-imports", fixable: "code" },
      ],
      "@typescript-eslint/no-import-type-side-effects": "error",
 
      // 未使用変数
      "@typescript-eslint/no-unused-vars": [
        "error",
        {
          argsIgnorePattern: "^_",
          varsIgnorePattern: "^_",
          caughtErrorsIgnorePattern: "^_",
        },
      ],
 
      // switch 網羅性
      "@typescript-eslint/switch-exhaustiveness-check": "error",
    },
  },
 
  // 5. テストファイル用の緩和
  {
    files: ["**/*.test.ts", "**/*.spec.ts"],
    rules: {
      "@typescript-eslint/no-explicit-any": "off",
      "@typescript-eslint/no-non-null-assertion": "off",
      "@typescript-eslint/no-unsafe-assignment": "off",
    },
  },
 
  // 6. 除外パターン
  {
    ignores: [
      "dist/",
      "build/",
      "coverage/",
      "node_modules/",
      "**/*.js",
      "**/*.mjs",
    ],
  },
 
  // 7. Prettier 連携
  prettierConfig
);

{
  "scripts": {
    // 基本
    "lint": "eslint src/",
    "lint:fix": "eslint src/ --fix",
 
    // 型チェックと lint を同時実行
    "check": "tsc --noEmit && eslint src/",
 
    // 並列実行 (npm-run-all 使用)
    "check:parallel": "run-p typecheck lint",
    "typecheck": "tsc --noEmit",
 
    // タイミング情報付き (パフォーマンス調査用)
    "lint:timing": "TIMING=1 eslint src/",
 
    // キャッシュをクリア
    "lint:clean": "eslint src/ --cache --cache-location .eslintcache",
 
    // 変更ファイルのみ
    "lint:changed": "eslint $(git diff --name-only --diff-filter=d HEAD -- '*.ts' '*.tsx')",
 
    // CI 用 (警告もエラーとして扱う)
    "lint:ci": "eslint src/ --max-warnings 0"
  },
  "devDependencies": {
    "eslint": "^9.0.0",
    "typescript-eslint": "^8.0.0",
    "npm-run-all2": "^6.0.0"
  }
}

// .vscode/settings.json
{
  // ESLint 拡張機能の設定
  "eslint.enable": true,
  "eslint.validate": [
    "javascript",
    "javascriptreact",
    "typescript",
    "typescriptreact"
  ],
 
  // Flat Config を有効化
  "eslint.useFlatConfig": true,
 
  // 保存時に自動修正
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit"
  },
 
  // Prettier との統合
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "[typescript]": {
    "editor.defaultFormatter": "esbenp.prettier-vscode",
    "editor.formatOnSave": true
  },
 
  // ESLint のワーキングディレクトリ
  "eslint.workingDirectories": [
    { "mode": "auto" }
  ],
 
  // パフォーマンス設定
  "eslint.lintTask.options": "--cache",
 
  // デバッグ用
  "eslint.trace.server": "off" // 問題発生時は "verbose" に変更
}

// .vscode/extensions.json (推奨拡張機能)
{
  "recommendations": [
    "dbaeumer.vscode-eslint",
    "esbenp.prettier-vscode"
  ]
}

# husky + lint-staged のインストール
npm install -D husky lint-staged
npx husky init

// package.json
{
  "scripts": {
    "prepare": "husky"
  },
  "lint-staged": {
    "*.{ts,tsx}": [
      "eslint --fix",
      "prettier --write"
    ]
  }
}

# .husky/pre-commit
npm run lint-staged

// eslint.config.ts
import tseslint from "typescript-eslint";
 
export default tseslint.config(
  ...tseslint.configs.recommended
);

// eslint.config.ts
import tseslint from "typescript-eslint";
 
export default tseslint.config(
  ...tseslint.configs.recommendedTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  }
);

// eslint.config.ts
import tseslint from "typescript-eslint";
 
export default tseslint.config(
  ...tseslint.configs.strictTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  }
);

// eslint.config.ts
import tseslint from "typescript-eslint";
 
export default tseslint.config(
  ...tseslint.configs.strictTypeChecked,
  ...tseslint.configs.stylisticTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  }
);

// 新規プロジェクト: strictTypeChecked + stylisticTypeChecked
export default tseslint.config(
  ...tseslint.configs.strictTypeChecked,
  ...tseslint.configs.stylisticTypeChecked
);
 
// 既存プロジェクト: recommendedTypeChecked からスタート
export default tseslint.config(
  ...tseslint.configs.recommendedTypeChecked
);
 
// レガシーコード: recommended のみ
export default tseslint.config(
  ...tseslint.configs.recommended
);
 
// ライブラリ: strictTypeChecked + 独自ルール
export default tseslint.config(
  ...tseslint.configs.strictTypeChecked,
  {
    rules: {
      "@typescript-eslint/explicit-module-boundary-types": "error",
      "@typescript-eslint/explicit-function-return-type": "error",
    },
  }
);

// NG: Promise を放置
async function fetchData(): Promise<void> {
  const response = await fetch("/api/data");
  response.json(); // 警告: Promises must be awaited, end with a call to .catch, or end with a call to .then with a rejection handler
  // ↑ この Promise は処理されず、エラーが握りつぶされる
}
 
// OK: await する
async function fetchData(): Promise<void> {
  const response = await fetch("/api/data");
  const data = await response.json();
  console.log(data);
}
 
// OK: .catch() でエラーハンドリング
async function fetchData(): Promise<void> {
  const response = await fetch("/api/data");
  response.json().catch((err) => {
    console.error("JSON parse error:", err);
  });
}
 
// OK: void 演算子で意図的に無視
async function backgroundTask(): Promise<void> {
  void someAsyncOperation(); // バックグラウンドで実行
}
 
// NG: 変数に代入しても await しなければエラー
async function fetchData(): Promise<void> {
  const promise = fetch("/api/data"); // 警告
  // promise を await していない
}

// 問題: データベース接続の切断を忘れる
class UserRepository {
  async save(user: User): Promise<void> {
    await db.insert(users).values(user);
    db.close(); // 警告: db.close() は Promise を返すが await していない
  }
}
 
// 修正
class UserRepository {
  async save(user: User): Promise<void> {
    await db.insert(users).values(user);
    await db.close();
  }
}

// NG: forEach のコールバックに async 関数
const items = [1, 2, 3];
items.forEach(async (item) => {
  // 警告: Promise returned in function argument where a void return was expected
  await processItem(item);
});
// forEach は返り値の Promise を待たないため、エラーが握りつぶされる
 
// OK: for...of で順次処理
for (const item of items) {
  await processItem(item);
}
 
// OK: Promise.all で並列処理
await Promise.all(items.map((item) => processItem(item)));
 
// NG: 条件式に Promise
if (fetchUser(id)) { // 警告: Expected non-Promise value in a boolean conditional
  // Promise は常に truthy なので、この条件は常に true
}
 
// OK: await してから条件判定
const user = await fetchUser(id);
if (user) {
  // ...
}
 
// NG: addEventListener に async 関数
button.addEventListener("click", async () => {
  // 警告: Promise-returning function provided to attribute where a void return was expected
  await handleClick();
});
 
// OK: エラーハンドリング付き
button.addEventListener("click", () => {
  handleClick().catch((err) => {
    console.error("Click handler error:", err);
  });
});

// 問題: Array.prototype.map の誤用
async function getUserNames(ids: string[]): Promise<string[]> {
  // NG: map は Promise を待たない
  const names = ids.map(async (id) => {
    const user = await fetchUser(id);
    return user.name;
  });
  return names; // 型エラー: Promise<string>[] を返している
}
 
// 修正
async function getUserNames(ids: string[]): Promise<string[]> {
  const names = await Promise.all(
    ids.map(async (id) => {
      const user = await fetchUser(id);
      return user.name;
    })
  );
  return names;
}

// NG: Promise でない値を await
function getUser(id: string): User {
  return database[id];
}
 
async function main() {
  const user = await getUser("123"); // 警告: Unexpected await on a non-Promise value
}
 
// OK: Promise を返す関数のみ await
async function getUser(id: string): Promise<User> {
  return fetch(`/api/users/${id}`).then((r) => r.json());
}
 
async function main() {
  const user = await getUser("123");
}
 
// NG: 既に await された値を再度 await
async function fetchData(): Promise<Data> {
  const response = await fetch("/api/data");
  const data = await await response.json(); // 警告: 二重 await
  return data;
}

// NG: 常に true の条件
function process(value: string) {
  if (value !== undefined) { // 警告: Unnecessary conditional, value is always defined
    // value は string 型なので undefined になることはない
  }
}
 
// OK: Optional な値の条件チェック
function process(value?: string) {
  if (value !== undefined) {
    // value は string | undefined なので適切
  }
}
 
// NG: 常に false の条件
function check(num: number) {
  if (num === "123") { // 警告: This comparison appears to be unintentional
    // number と string は等価になることはない
  }
}
 
// NG: 不要な null チェック
function greet(name: string) {
  return name ?? "Guest"; // 警告: Unnecessary nullish coalescing operator
  // name は string 型なので null/undefined にならない
}
 
// OK: Optional な値への null チェック
function greet(name?: string) {
  return name ?? "Guest";
}

// @typescript-eslint/switch-exhaustiveness-check: "error"
 
type Status = "active" | "inactive" | "pending" | "archived";
 
// NG: ケースが不足
function getLabel(status: Status): string {
  switch (status) {
    case "active":
      return "有効";
    case "inactive":
      return "無効";
    case "pending":
      return "保留中";
    // 警告: Switch is not exhaustive. Missing case: "archived"
  }
}
 
// OK: 全ケースを網羅
function getLabel(status: Status): string {
  switch (status) {
    case "active":
      return "有効";
    case "inactive":
      return "無効";
    case "pending":
      return "保留中";
    case "archived":
      return "アーカイブ済み";
  }
}
 
// OK: default で網羅
function getLabel(status: Status): string {
  switch (status) {
    case "active":
      return "有効";
    case "inactive":
      return "無効";
    case "pending":
      return "保留中";
    default:
      return "その他";
  }
}

// never 型を使った網羅性チェック
function assertNever(value: never): never {
  throw new Error(`Unexpected value: ${value}`);
}
 
function getLabel(status: Status): string {
  switch (status) {
    case "active":
      return "有効";
    case "inactive":
      return "無効";
    case "pending":
      return "保留中";
    default:
      // Status に新しい値が追加されると、ここで型エラーが発生
      return assertNever(status);
  }
}

// no-unsafe-assignment
function process(data: any) {
  const value: string = data; // 警告: Unsafe assignment of an any value
}
 
// no-unsafe-call
function execute(fn: any) {
  fn(); // 警告: Unsafe call of an any typed value
}
 
// no-unsafe-member-access
function getValue(obj: any) {
  return obj.value; // 警告: Unsafe member access .value on an any value
}
 
// no-unsafe-return
function getData(): string {
  const data: any = fetchData();
  return data; // 警告: Unsafe return of an any typed value
}
 
// OK: 型アサーションまたは型ガードを使用
function process(data: unknown) {
  if (typeof data === "string") {
    const value: string = data;
  }
}
 
// OK: Zod などのバリデーションライブラリを使用
import { z } from "zod";
 
const UserSchema = z.object({
  name: z.string(),
  age: z.number(),
});
 
function process(data: unknown) {
  const user = UserSchema.parse(data); // 型安全
  console.log(user.name);
}

// NG: || を使うと 0 や '' が falsy として扱われる
function getCount(count: number | undefined): number {
  return count || 0; // 警告: Prefer using nullish coalescing operator
  // count が 0 の場合も 0 が返る (意図しない動作)
}
 
// OK: ?? を使う
function getCount(count: number | undefined): number {
  return count ?? 0;
  // count が undefined の場合のみ 0 が返る
}
 
// 実際の問題例
interface Config {
  port?: number;
  debug?: boolean;
}
 
// NG: || を使うと意図しない動作
function getConfig(config: Config) {
  const port = config.port || 3000; // port: 0 が設定されても 3000 になる
  const debug = config.debug || false; // debug: false が設定されても false になる (一見正しいが意図が不明確)
}
 
// OK: ?? を使う
function getConfig(config: Config) {
  const port = config.port ?? 3000;
  const debug = config.debug ?? false;
}

// 1. projectService を使用 (v8 以降)
{
  languageOptions: {
    parserOptions: {
      projectService: true, // 従来の project より高速
      tsconfigRootDir: import.meta.dirname,
    },
  },
}
 
// 2. キャッシュを有効化
// package.json
{
  "scripts": {
    "lint": "eslint src/ --cache --cache-location .eslintcache"
  }
}
 
// 3. 変更ファイルのみ lint
{
  "scripts": {
    "lint:changed": "eslint $(git diff --name-only --diff-filter=d HEAD -- '*.ts')"
  }
}

// my-rule.ts
import { ESLintUtils } from "@typescript-eslint/utils";
 
const createRule = ESLintUtils.RuleCreator(
  (name) => `https://example.com/rule/${name}`
);
 
export const myRule = createRule({
  name: "my-rule",
  meta: {
    type: "problem",
    docs: {
      description: "ルールの説明",
    },
    messages: {
      errorMessage: "エラーメッセージ: {{value}}",
    },
    schema: [],
  },
  defaultOptions: [],
  create(context) {
    return {
      // AST ノードに対するビジター関数
      Identifier(node) {
        if (node.name === "badName") {
          context.report({
            node,
            messageId: "errorMessage",
            data: {
              value: node.name,
            },
          });
        }
      },
    };
  },
});

// rules/no-console-log.ts
import { ESLintUtils } from "@typescript-eslint/utils";
import type { TSESTree } from "@typescript-eslint/utils";
 
const createRule = ESLintUtils.RuleCreator(
  (name) => `https://example.com/rule/${name}`
);
 
export const noConsoleLog = createRule({
  name: "no-console-log",
  meta: {
    type: "suggestion",
    docs: {
      description: "console.log を禁止し、logger.info を使用させる",
    },
    messages: {
      useLogger: "console.log の代わりに logger.info を使用してください",
    },
    fixable: "code",
    schema: [],
  },
  defaultOptions: [],
  create(context) {
    return {
      MemberExpression(node: TSESTree.MemberExpression) {
        // console.log をチェック
        if (
          node.object.type === "Identifier" &&
          node.object.name === "console" &&
          node.property.type === "Identifier" &&
          node.property.name === "log"
        ) {
          context.report({
            node,
            messageId: "useLogger",
            fix(fixer) {
              // 自動修正: console.log → logger.info
              return fixer.replaceText(node, "logger.info");
            },
          });
        }
      },
    };
  },
});

// rules/no-untyped-fetch.ts
import { ESLintUtils } from "@typescript-eslint/utils";
import type { TSESTree } from "@typescript-eslint/utils";
 
const createRule = ESLintUtils.RuleCreator(
  (name) => `https://example.com/rule/${name}`
);
 
export const noUntypedFetch = createRule({
  name: "no-untyped-fetch",
  meta: {
    type: "problem",
    docs: {
      description: "fetch の返り値は型アサーションまたはバリデーションが必要",
    },
    messages: {
      untypedFetch: "fetch の返り値を型安全に扱ってください (Zod, as 等)",
    },
    schema: [],
  },
  defaultOptions: [],
  create(context) {
    const services = ESLintUtils.getParserServices(context);
    const checker = services.program.getTypeChecker();
 
    return {
      AwaitExpression(node: TSESTree.AwaitExpression) {
        if (node.argument.type !== "CallExpression") return;
 
        const callee = node.argument.callee;
        if (callee.type !== "Identifier" || callee.name !== "fetch") return;
 
        // 親ノードをチェック
        const parent = node.parent;
 
        // 型アサーションがあるかチェック
        if (parent?.type === "TSAsExpression") return;
 
        // 変数宣言の場合、型注釈があるかチェック
        if (
          parent?.type === "VariableDeclarator" &&
          parent.id.type === "Identifier" &&
          parent.id.typeAnnotation
        ) {
          return;
        }
 
        context.report({
          node,
          messageId: "untypedFetch",
        });
      },
    };
  },
});

// NG: 型情報なし
const response = await fetch("/api/users");
 
// OK: 型アサーション
const response = await fetch("/api/users") as Response<User[]>;
 
// OK: 型注釈付き変数宣言
const response: Response<User[]> = await fetch("/api/users");
 
// OK: Zod バリデーション
const response = await fetch("/api/users");
const users = UserArraySchema.parse(await response.json());

// index.ts
import { noConsoleLog } from "./rules/no-console-log";
import { noUntypedFetch } from "./rules/no-untyped-fetch";
 
export default {
  rules: {
    "no-console-log": noConsoleLog,
    "no-untyped-fetch": noUntypedFetch,
  },
};

// eslint.config.ts
import myPlugin from "./my-eslint-plugin";
 
export default [
  {
    plugins: {
      "my-plugin": myPlugin,
    },
    rules: {
      "my-plugin/no-console-log": "error",
      "my-plugin/no-untyped-fetch": "error",
    },
  },
];

// コード
const user = { name: "Alice" };
 
// AST (抜粋)
{
  type: "VariableDeclaration",
  declarations: [{
    type: "VariableDeclarator",
    id: { type: "Identifier", name: "user" },
    init: {
      type: "ObjectExpression",
      properties: [{
        type: "Property",
        key: { type: "Identifier", name: "name" },
        value: { type: "Literal", value: "Alice" }
      }]
    }
  }]
}

npm install -D eslint-config-prettier

// eslint.config.ts
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
import prettierConfig from "eslint-config-prettier";
 
export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.strictTypeChecked,
  ...tseslint.configs.stylisticTypeChecked,
  prettierConfig, // 最後に配置して競合ルールを無効化
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  }
);

// .prettierrc
{
  "semi": true,
  "singleQuote": false,
  "tabWidth": 2,
  "trailingComma": "all",
  "printWidth": 100,
  "arrowParens": "always",
  "endOfLine": "lf"
}

// package.json
{
  "scripts": {
    // 1. Prettier でフォーマット
    "format": "prettier --write 'src/**/*.{ts,tsx}'",
 
    // 2. ESLint でチェック
    "lint": "eslint src/",
 
    // 3. まとめて実行
    "check": "npm run format && npm run lint"
  }
}

// .vscode/settings.json
{
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit"
  },
  "[typescript]": {
    "editor.defaultFormatter": "esbenp.prettier-vscode"
  }
}

// 無効化されるルール例
 
// インデント
"@typescript-eslint/indent": "off",
 
// 改行
"@typescript-eslint/comma-dangle": "off",
 
// セミコロン
"@typescript-eslint/semi": "off",
 
// クォート
"@typescript-eslint/quotes": "off",
 
// スペース
"@typescript-eslint/space-before-function-paren": "off",

// eslint.config.ts
export default tseslint.config(
  ...tseslint.configs.strictTypeChecked,
  {
    rules: {
      // Prettier がフォーマットするルールをオフ
      "@typescript-eslint/indent": "off",
      "@typescript-eslint/quotes": "off",
      "@typescript-eslint/semi": "off",
      "@typescript-eslint/comma-dangle": "off",
 
      // 品質ルールは有効化
      "@typescript-eslint/no-explicit-any": "error",
      "@typescript-eslint/no-floating-promises": "error",
    },
  }
);

npm install -D dprint

// dprint.json
{
  "typescript": {
    "semiColons": "prefer",
    "quoteStyle": "alwaysDouble",
    "indentWidth": 2,
    "lineWidth": 100
  },
  "includes": ["**/*.{ts,tsx,js,jsx,json}"],
  "excludes": ["node_modules", "dist"]
}

// package.json
{
  "scripts": {
    "format": "dprint fmt",
    "format:check": "dprint check"
  }
}

// eslint.config.ts (React + TypeScript)
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
import reactPlugin from "eslint-plugin-react";
import reactHooks from "eslint-plugin-react-hooks";
import reactRefresh from "eslint-plugin-react-refresh";
import jsxA11y from "eslint-plugin-jsx-a11y";
 
export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.strictTypeChecked,
  ...tseslint.configs.stylisticTypeChecked,
  {
    files: ["**/*.{ts,tsx}"],
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  },
  {
    files: ["**/*.{jsx,tsx}"],
    plugins: {
      react: reactPlugin,
      "react-hooks": reactHooks,
      "react-refresh": reactRefresh,
      "jsx-a11y": jsxA11y,
    },
    rules: {
      ...reactPlugin.configs.recommended.rules,
      ...reactHooks.configs.recommended.rules,
 
      // React Refresh
      "react-refresh/only-export-components": [
        "warn",
        { allowConstantExport: true },
      ],
 
      // React 設定
      "react/react-in-jsx-scope": "off", // React 17+ では不要
      "react/prop-types": "off", // TypeScript を使うので不要
 
      // Hooks ルール
      "react-hooks/rules-of-hooks": "error",
      "react-hooks/exhaustive-deps": "warn",
 
      // アクセシビリティ
      ...jsxA11y.configs.recommended.rules,
    },
    settings: {
      react: {
        version: "detect",
      },
    },
  }
);

// eslint.config.ts (Next.js)
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
import nextPlugin from "@next/eslint-plugin-next";
 
export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.recommendedTypeChecked,
  {
    files: ["**/*.{ts,tsx}"],
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  },
  {
    plugins: {
      "@next/next": nextPlugin,
    },
    rules: {
      ...nextPlugin.configs.recommended.rules,
      ...nextPlugin.configs["core-web-vitals"].rules,
    },
  },
  {
    // App Router のサーバーコンポーネント
    files: ["app/**/*.tsx"],
    rules: {
      "react-hooks/rules-of-hooks": "off", // サーバーコンポーネントでは不要
    },
  }
);

// eslint.config.ts (Node.js)
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
import nodePlugin from "eslint-plugin-node";
import securityPlugin from "eslint-plugin-security";
 
export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.strictTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
      globals: {
        // Node.js グローバル変数
        __dirname: "readonly",
        __filename: "readonly",
        process: "readonly",
        Buffer: "readonly",
      },
    },
  },
  {
    plugins: {
      node: nodePlugin,
      security: securityPlugin,
    },
    rules: {
      // Node.js ルール
      "node/no-unsupported-features/es-syntax": "off", // TypeScript で transpile するため
      "node/no-missing-import": "off", // TypeScript の解決に任せる
 
      // セキュリティルール
      ...securityPlugin.configs.recommended.rules,
      "security/detect-object-injection": "off", // 誤検知が多いため
 
      // TypeScript 固有
      "@typescript-eslint/no-floating-promises": "error",
      "@typescript-eslint/no-misused-promises": "error",
    },
  }
);

// eslint.config.ts (ライブラリ)
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
 
export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.strictTypeChecked,
  ...tseslint.configs.stylisticTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        projectService: true,
        tsconfigRootDir: import.meta.dirname,
      },
    },
  },
  {
    files: ["src/**/*.ts"],
    rules: {
      // 公開 API は全て型を明示
      "@typescript-eslint/explicit-module-boundary-types": "error",
      "@typescript-eslint/explicit-function-return-type": [
        "error",
        {
          allowExpressions: false,
          allowTypedFunctionExpressions: true,
        },
      ],
 
      // any を完全禁止
      "@typescript-eslint/no-explicit-any": "error",
      "@typescript-eslint/no-unsafe-assignment": "error",
      "@typescript-eslint/no-unsafe-call": "error",
      "@typescript-eslint/no-unsafe-member-access": "error",
      "@typescript-eslint/no-unsafe-return": "error",
 
      // 一貫性のある型定義
      "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
      "@typescript-eslint/consistent-type-imports": [
        "error",
        { prefer: "type-imports", fixable: "code" },
      ],
 
      // 命名規則
      "@typescript-eslint/naming-convention": [
        "error",
        {
          selector: "default",
          format: ["camelCase"],
        },
        {
          selector: "variable",
          format: ["camelCase", "UPPER_CASE"],
        },
        {
          selector: "typeLike",
          format: ["PascalCase"],
        },
        {
          selector: "interface",
          format: ["PascalCase"],
          custom: {
            regex: "^I[A-Z]",
            match: false, // I プレフィックス禁止
          },
        },
      ],
    },
  },
  {
    // テストファイルは緩和
    files: ["**/*.test.ts", "**/*.spec.ts"],
    rules: {
      "@typescript-eslint/no-explicit-any": "off",
      "@typescript-eslint/explicit-function-return-type": "off",
    },
  }
);

// eslint.config.ts (root)
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
import prettierConfig from "eslint-config-prettier";
 
export default tseslint.config(
  eslint.configs.recommended,
  ...tseslint.configs.strictTypeChecked,
  {
    languageOptions: {
      parserOptions: {
        projectService: {
          allowDefaultProject: ["*.js", "*.mjs"],
        },
        tsconfigRootDir: import.meta.dirname,
      },
    },
  },
  {
    rules: {
      // モノレポ全体で適用するルール
      "@typescript-eslint/no-explicit-any": "error",
      "@typescript-eslint/no-floating-promises": "error",
      "@typescript-eslint/consistent-type-imports": [
        "error",
        { prefer: "type-imports", fixable: "code" },
      ],
    },
  },
  prettierConfig,
  {
    ignores: [
      "**/dist/**",
      "**/build/**",
      "**/node_modules/**",
      "**/*.js",
    ],
  }
);

// packages/shared/eslint.config.ts (ライブラリ)
import rootConfig from "../../eslint.config.ts";
 
export default [
  ...rootConfig,
  {
    files: ["src/**/*.ts"],
    rules: {
      // ライブラリは特に厳格
      "@typescript-eslint/explicit-module-boundary-types": "error",
      "@typescript-eslint/explicit-function-return-type": "error",
    },
  },
];

// packages/web/eslint.config.ts (React)
import rootConfig from "../../eslint.config.ts";
import reactHooks from "eslint-plugin-react-hooks";
import reactRefresh from "eslint-plugin-react-refresh";
 
export default [
  ...rootConfig,
  {
    files: ["src/**/*.{ts,tsx}"],
    plugins: {
      "react-hooks": reactHooks,
      "react-refresh": reactRefresh,
    },
    rules: {
      ...reactHooks.configs.recommended.rules,
      "react-refresh/only-export-components": [
        "warn",
        { allowConstantExport: true },
      ],
    },
  },
];

// packages/api/eslint.config.ts (Node.js)
import rootConfig from "../../eslint.config.ts";
import nodePlugin from "eslint-plugin-node";
 
export default [
  ...rootConfig,
  {
    files: ["src/**/*.ts"],
    plugins: {
      node: nodePlugin,
    },
    rules: {
      // Node.js 固有ルール
      "node/no-unsupported-features/es-syntax": "off",
    },
  },
];

// package.json (root)
{
  "scripts": {
    "lint": "npm run lint --workspaces --if-present",
    "lint:fix": "npm run lint:fix --workspaces --if-present",
    "typecheck": "npm run typecheck --workspaces --if-present"
  },
  "workspaces": [
    "packages/*"
  ]
}

// packages/web/package.json
{
  "scripts": {
    "lint": "eslint src/",
    "lint:fix": "eslint src/ --fix",
    "typecheck": "tsc --noEmit"
  }
}

// turbo.json
{
  "pipeline": {
    "lint": {
      "cache": true,
      "outputs": []
    },
    "typecheck": {
      "cache": true,
      "outputs": []
    }
  }
}

// package.json (root)
{
  "scripts": {
    "lint": "turbo run lint",
    "typecheck": "turbo run typecheck"
  }
}

# .github/workflows/lint.yml
name: Lint
 
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]
 
jobs:
  lint:
    runs-on: ubuntu-latest
 
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
 
      - name: Install dependencies
        run: npm ci
 
      - name: Type check
        run: npm run typecheck
 
      - name: ESLint
        run: npm run lint -- --max-warnings 0
 
      # ESLint の結果を PR コメントに出力
      - uses: reviewdog/action-eslint@v1
        if: always()
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          reporter: github-pr-review
          eslint_flags: "src/"

# .github/workflows/lint-changed.yml
name: Lint Changed Files
 
on:
  pull_request:
 
jobs:
  lint:
    runs-on: ubuntu-latest
 
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0 # 全履歴を取得
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
 
      - run: npm ci
 
      - name: Get changed TypeScript files
        id: changed-files
        uses: tj-actions/changed-files@v42
        with:
          files: |
            **/*.ts
            **/*.tsx
 
      - name: Lint changed files
        if: steps.changed-files.outputs.any_changed == 'true'
        run: |
          echo "Changed files: ${{ steps.changed-files.outputs.all_changed_files }}"
          npx eslint ${{ steps.changed-files.outputs.all_changed_files }}

# .github/workflows/lint-with-cache.yml
name: Lint with Cache
 
on: [pull_request]
 
jobs:
  lint:
    runs-on: ubuntu-latest
 
    steps:
      - uses: actions/checkout@v4
 
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
 
      - run: npm ci
 
      # ESLint キャッシュを復元
      - name: Restore ESLint cache
        uses: actions/cache@v4
        with:
          path: .eslintcache
          key: eslint-${{ runner.os }}-${{ hashFiles('**/eslint.config.ts') }}
 
      - name: Lint
        run: npm run lint -- --cache --cache-location .eslintcache
 
      # 型チェックキャッシュも活用
      - name: Restore tsc cache
        uses: actions/cache@v4
        with:
          path: .tsbuildinfo
          key: tsc-${{ runner.os }}-${{ hashFiles('**/tsconfig.json') }}
 
      - name: Type check
        run: npm run typecheck

# .github/workflows/lint-parallel.yml
name: Lint (Parallel)
 
on: [pull_request]
 
jobs:
  lint:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        package: [shared, web, api] # モノレポの各パッケージ
 
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
 
      - run: npm ci
 
      - name: Lint ${{ matrix.package }}
        run: npm run lint -w packages/${{ matrix.package }}

# .gitlab-ci.yml
stages:
  - lint
  - test
 
lint:
  stage: lint
  image: node:20
  cache:
    paths:
      - node_modules/
      - .eslintcache
  script:
    - npm ci
    - npm run lint -- --cache --cache-location .eslintcache --max-warnings 0
  artifacts:
    reports:
      junit: eslint-report.xml

// package.json
{
  "scripts": {
    "lint:ci": "eslint src/ --format json --output-file eslint-report.json || true"
  }
}

# .github/workflows/lint-report.yml
- name: Lint with JSON report
  run: npm run lint:ci
 
- name: Upload ESLint report
  uses: actions/upload-artifact@v4
  if: always()
  with:
    name: eslint-report
    path: eslint-report.json

# TIMING 環境変数で各ルールの実行時間を計測
TIMING=1 eslint src/
 
# 出力例:
Rule                                    | Time (ms) | Relative
:---------------------------------------|----------:|--------:
@typescript-eslint/no-floating-promises |  2456.234 |    32.1%
@typescript-eslint/no-unsafe-assignment |  1234.567 |    16.1%
@typescript-eslint/no-misused-promises  |   987.654 |    12.9%
...

// package.json
{
  "scripts": {
    "lint:timing": "TIMING=1 eslint src/"
  }
}

// 従来の設定 (遅い)
{
  languageOptions: {
    parserOptions: {
      project: "./tsconfig.json",
      tsconfigRootDir: import.meta.dirname,
    },
  },
}
 
// v8 の設定 (高速)
{
  languageOptions: {
    parserOptions: {
      projectService: true, // TypeScript の Language Service を活用
      tsconfigRootDir: import.meta.dirname,
    },
  },
}

// package.json
{
  "scripts": {
    "lint": "eslint src/ --cache --cache-location .eslintcache",
    "lint:clean": "rm -rf .eslintcache && npm run lint"
  }
}

# eslint-parallel を使用
npm install -D eslint-parallel

// package.json
{
  "scripts": {
    "lint": "eslint-parallel src/**/*.ts"
  }
}

// eslint.config.ts
export default tseslint.config(
  ...tseslint.configs.recommendedTypeChecked,
  {
    rules: {
      // 型情報ルールで特に遅いもの
      "@typescript-eslint/no-unnecessary-condition": "off", // 遅い
      "@typescript-eslint/strict-boolean-expressions": "off", // 遅い
 
      // 必須のルールは残す
      "@typescript-eslint/no-floating-promises": "error",
      "@typescript-eslint/no-misused-promises": "error",
    },
  }
);

// eslint.config.ts
export default tseslint.config(
  // ...
  {
    ignores: [
      "**/node_modules/**",
      "**/dist/**",
      "**/build/**",
      "**/coverage/**",
      "**/*.min.js",
      "**/*.d.ts", // 型定義ファイルは除外
      "**/generated/**", // 自動生成ファイルは除外
    ],
  }
);

# .github/workflows/lint.yml
jobs:
  lint:
    runs-on: ubuntu-latest
 
    steps:
      # 1. シャローコピー（履歴不要）
      - uses: actions/checkout@v4
        with:
          fetch-depth: 1
 
      # 2. Node.js キャッシュ
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
 
      # 3. 依存関係キャッシュ
      - name: Cache node_modules
        uses: actions/cache@v4
        with:
          path: node_modules
          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
 
      # 4. ESLint キャッシュ
      - name: Cache ESLint
        uses: actions/cache@v4
        with:
          path: .eslintcache
          key: eslint-${{ runner.os }}-${{ hashFiles('**/eslint.config.ts') }}
 
      # 5. 並列実行
      - name: Lint
        run: eslint-parallel src/**/*.ts --cache

# インストール
npm install -D @biomejs/biome

// biome.json
{
  "$schema": "https://biomejs.dev/schemas/1.0.0/schema.json",
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "suspicious": {
        "noExplicitAny": "error"
      },
      "style": {
        "useConst": "error"
      }
    }
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineWidth": 100
  },
  "javascript": {
    "formatter": {
      "semicolons": "always",
      "quoteStyle": "double"
    }
  }
}

// package.json
{
  "scripts": {
    "lint": "biome lint src/",
    "format": "biome format --write src/",
    "check": "biome check --write src/" // lint + format
  }
}

# インストール
npm install -D oxlint

// .oxlintrc.json
{
  "rules": {
    "no-floating-promises": "warn",
    "no-explicit-any": "error"
  }
}

// package.json
{
  "scripts": {
    "lint": "oxlint src/"
  }
}

// package.json
{
  "scripts": {
    "lint:biome": "biome check --write src/",
    "lint:eslint": "eslint src/ --cache",
    "lint": "npm run lint:biome && npm run lint:eslint"
  }
}

// eslint.config.ts (型情報ルールのみ)
import tseslint from "typescript-eslint";
 
export default tseslint.config({
  languageOptions: {
    parserOptions: {
      projectService: true,
      tsconfigRootDir: import.meta.dirname,
    },
  },
  rules: {
    // 型情報ルールのみ有効化
    "@typescript-eslint/no-floating-promises": "error",
    "@typescript-eslint/no-misused-promises": "error",
    "@typescript-eslint/await-thenable": "error",
    "@typescript-eslint/no-unnecessary-condition": "error",
 
    // Biome でカバーされるルールは無効化
    "@typescript-eslint/no-unused-vars": "off",
    "@typescript-eslint/no-explicit-any": "off",
  },
});

// biome.json
{
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "suspicious": {
        "noExplicitAny": "error"
      }
    }
  },
  "formatter": {
    "enabled": true
  }
}