// 基本的な tsconfig.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist", "**/*.test.ts"]
}

// include: glob パターンで対象を指定
{
  "include": [
    "src/**/*",        // src 配下の全ファイル
    "src/**/*.ts",     // .ts ファイルのみ（明示的）
    "src/**/*.tsx",    // .tsx ファイルを含む
    "types/**/*.d.ts"  // 型定義ファイル
  ]
}
 
// exclude: include で指定した中から除外
// ※ exclude はデフォルトで node_modules, bower_components, jspm_packages, outDir を除外
{
  "exclude": [
    "node_modules",      // デフォルトで除外されるが明示推奨
    "dist",              // ビルド出力先
    "**/*.test.ts",      // テストファイル
    "**/*.spec.ts",      // スペックファイル
    "**/__tests__/**",   // テストディレクトリ
    "coverage",          // カバレッジ出力先
    "scripts"            // ビルドスクリプト等
  ]
}
 
// files: 個別のファイルを直接指定（glob パターン不可）
// 少数の特定ファイルだけをコンパイルしたい場合に使用
{
  "files": [
    "src/index.ts",
    "src/global.d.ts"
  ]
}

// tsconfig.base.json -- 共通設定
{
  "compilerOptions": {
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "verbatimModuleSyntax": true
  }
}
 
// tsconfig.json -- アプリ用（継承 + 上書き）
{
  "extends": "./tsconfig.base.json",
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "outDir": "./dist",
    "rootDir": "./src",
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "jsx": "react-jsx"
  },
  "include": ["src/**/*"]
}
 
// tsconfig.test.json -- テスト用
{
  "extends": "./tsconfig.base.json",
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "types": ["vitest/globals"],
    "noEmit": true
  },
  "include": ["src/**/*", "tests/**/*"]
}
 
// tsconfig.build.json -- ビルド専用（テスト除外）
{
  "extends": "./tsconfig.json",
  "compilerOptions": {
    "noEmit": false,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true
  },
  "exclude": ["**/*.test.ts", "**/*.spec.ts", "**/__tests__/**"]
}

# コミュニティが提供する推奨設定をインストール
npm install -D @tsconfig/node20
npm install -D @tsconfig/strictest
npm install -D @tsconfig/vite-react

// @tsconfig/node20 を使った例
{
  "extends": "@tsconfig/node20/tsconfig.json",
  "compilerOptions": {
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"]
}
 
// @tsconfig/strictest を使って最大限の厳密性を確保
{
  "extends": "@tsconfig/strictest/tsconfig.json",
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler"
  }
}

{
  "watchOptions": {
    // ファイル監視の方法
    "watchFile": "useFsEvents",
    // ディレクトリ監視の方法
    "watchDirectory": "useFsEvents",
    // ポーリングのフォールバック間隔（ms）
    "fallbackPolling": "dynamicPriority",
    // 同時変更の待機時間
    "synchronousWatchDirectory": false,
    // 監視対象から除外
    "excludeDirectories": ["**/node_modules", "dist"],
    // ファイル監視対象の追加
    "excludeFiles": []
  }
}

// strictNullChecks: true の効果
function getUser(id: string): User | null {
  // ...
  return null;
}
 
const user = getUser("1");
// user.name;  // エラー: Object is possibly 'null'
if (user) {
  user.name; // OK: null チェック後
}
 
// Optional Chaining との組み合わせ
const name = user?.name; // 型: string | undefined
const upper = user?.name?.toUpperCase() ?? "Unknown";
 
// Non-null Assertion（注意して使用）
const forcedName = user!.name; // 型: string（null の可能性を無視）
// ↑ ランタイムで null だとクラッシュするため、確実な場合のみ使用
 
// strictFunctionTypes: true の効果（反変性チェック）
type Handler = (event: MouseEvent) => void;
const handler: Handler = (event: Event) => {}; // エラー: 反変
// MouseEvent は Event のサブタイプだが、Handler は MouseEvent を要求
// Event の handler を MouseEvent の handler として使うと
// MouseEvent 固有のプロパティにアクセスできない可能性がある
 
// strictFunctionTypes の実践例
interface Animal {
  name: string;
}
interface Dog extends Animal {
  breed: string;
}
 
type Comparer<T> = (a: T, b: T) => number;
const animalComparer: Comparer<Animal> = (a, b) => a.name.localeCompare(b.name);
// const dogComparer: Comparer<Dog> = animalComparer; // strict: true ではエラー
 
// strictBindCallApply: true の効果
function greet(name: string, age: number): string {
  return `Hello ${name}, age ${age}`;
}
greet.call(undefined, "Alice", 30);       // OK
// greet.call(undefined, "Alice", "thirty"); // エラー: string は number に代入不可
greet.bind(undefined, "Alice")(30);       // OK: 部分適用
// greet.bind(undefined, "Alice")("thirty"); // エラー
 
// strictPropertyInitialization: true の効果
class User {
  name: string;        // エラー: 初期化されていない
  email: string = "";  // OK: 初期値あり
  age?: number;        // OK: optional
  id!: string;         // OK: definite assignment assertion
 
  constructor(name: string) {
    this.name = name;  // OK: コンストラクタで初期化
  }
}
 
// noImplicitAny: true の効果
function processData(data) {} // エラー: Parameter 'data' implicitly has an 'any' type
function processData(data: unknown) {} // OK: 明示的に型指定
 
// useUnknownInCatchVariables: true の効果
try {
  throw new Error("boom");
} catch (error) {
  // error の型は unknown（true の場合）
  // error の型は any（false の場合）
  if (error instanceof Error) {
    console.log(error.message); // OK: Error 型に絞り込み
  }
}

// noUncheckedIndexedAccess: true（非常に推奨）
// 配列やオブジェクトのインデックスアクセスに undefined を追加
const arr: string[] = ["a", "b", "c"];
const item = arr[5]; // 型: string | undefined（true の場合）
                      // 型: string（false の場合）
 
// 安全な使用パターン
if (item !== undefined) {
  console.log(item.toUpperCase()); // OK: undefined チェック後
}
 
// for...of や forEach は影響を受けない
for (const item of arr) {
  console.log(item.toUpperCase()); // OK: item は string
}
 
// Record 型のインデックスアクセスにも適用
const dict: Record<string, number> = { a: 1, b: 2 };
const value = dict["unknown"]; // 型: number | undefined
// これにより辞書型の安全なアクセスが保証される
 
// exactOptionalPropertyTypes: true
// undefined の明示的な代入と省略を区別
interface Config {
  debug?: boolean;
}
const config1: Config = {};                        // OK: debug を省略
const config2: Config = { debug: true };           // OK
const config3: Config = { debug: undefined };      // エラー!
// undefined を明示的に代入するなら debug?: boolean | undefined と書く
 
// この区別が重要な理由:
// Object.hasOwn(config, "debug") の結果が異なる
// 省略: false、undefined代入: true
 
// noPropertyAccessFromIndexSignature: true
// インデックスシグネチャへのドットアクセスを禁止
interface Dict {
  [key: string]: string;
  knownKey: string;
}
declare const dict: Dict;
dict.knownKey;      // OK: 既知のプロパティ
dict.unknownKey;    // エラー: use dict["unknownKey"] instead
dict["unknownKey"]; // OK: ブラケットアクセスを強制
 
// noImplicitOverride: true
// オーバーライドを明示的にする
class Base {
  greet() { return "hello"; }
}
 
class Derived extends Base {
  greet() { return "hi"; } // エラー: override キーワードが必要
  override greet() { return "hi"; } // OK
}
 
// noFallthroughCasesInSwitch: true
// switch のフォールスルーを禁止
function process(status: string) {
  switch (status) {
    case "active":
      console.log("Active");
      // エラー: break がない（フォールスルー）
    case "inactive":
      console.log("Inactive");
      break;
  }
}
 
// allowUnreachableCode: false
// 到達不可能なコードをエラーにする
function example(x: number) {
  return x;
  console.log("unreachable"); // エラー: Unreachable code detected
}
 
// allowUnusedLabels: false
// 未使用のラベルをエラーにする
function search(matrix: number[][]) {
  loop: // エラー: 使用されていないラベル
  for (const row of matrix) {
    for (const cell of row) {
      if (cell === 0) break;
    }
  }
}

// Step 1: 最小限の strict オプション（既存プロジェクト移行時）
{
  "compilerOptions": {
    "strict": false,
    "noImplicitAny": true
  }
}
 
// Step 2: null チェックの追加
{
  "compilerOptions": {
    "strict": false,
    "noImplicitAny": true,
    "strictNullChecks": true
  }
}
 
// Step 3: 関数型の厳密化
{
  "compilerOptions": {
    "strict": false,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictBindCallApply": true
  }
}
 
// Step 4: 全ての strict を有効化
{
  "compilerOptions": {
    "strict": true
  }
}
 
// Step 5: 追加の厳密性
{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,
    "noImplicitOverride": true,
    "noPropertyAccessFromIndexSignature": true,
    "noFallthroughCasesInSwitch": true
  }
}

// フロントエンド（バンドラー使用）
{
  "compilerOptions": {
    "module": "ESNext",
    "moduleResolution": "bundler"
  }
}
 
// Node.js バックエンド（ESM）
{
  "compilerOptions": {
    "module": "NodeNext",
    "moduleResolution": "NodeNext"
  }
}
 
// ライブラリ（ESM出力 + 型定義）
{
  "compilerOptions": {
    "module": "ESNext",
    "moduleResolution": "bundler",
    "declaration": true,
    "declarationMap": true
  }
}
 
// Node.js バックエンド（CJS -- レガシー）
{
  "compilerOptions": {
    "module": "CommonJS",
    "moduleResolution": "node"
  }
}

// moduleResolution: "bundler" の挙動
// 拡張子省略が可能（バンドラーが解決する前提）
import { utils } from "./utils";       // OK: ./utils.ts を発見
import { config } from "./config";     // OK: ./config.ts を発見
import { Button } from "@/components"; // OK: パスエイリアスもサポート
 
// moduleResolution: "NodeNext" の挙動
// 拡張子 .js が必須（Node.js ESM の仕様）
import { utils } from "./utils.js";    // OK: コンパイル後の拡張子を指定
import { config } from "./config.js";  // OK
// import { utils } from "./utils";    // エラー: 拡張子が必要
 
// NodeNext での package.json "type" フィールドとの関係
// package.json に "type": "module" → .ts ファイルは ESM として扱われる
// package.json に "type": "commonjs" → .ts ファイルは CJS として扱われる
// .mts ファイル → 常に ESM
// .cts ファイル → 常に CJS

// module: "Preserve" は入力のモジュール構文をそのまま保持
// moduleResolution: "bundler" と同等の解決を行いつつ、
// import/require を書いたとおりに出力する
 
// tsconfig.json
{
  "compilerOptions": {
    "module": "Preserve",
    "moduleResolution": "bundler"
  }
}
 
// 入力
import { foo } from "./foo";
const bar = require("./bar");
 
// 出力（そのまま保持）
import { foo } from "./foo";
const bar = require("./bar");
// バンドラーが最終的な解決を行う前提の設定

// ライブラリの package.json
{
  "name": "my-lib",
  "type": "module",
  "exports": {
    ".": {
      "import": {
        "types": "./dist/index.d.ts",
        "default": "./dist/index.js"
      },
      "require": {
        "types": "./dist/index.d.cts",
        "default": "./dist/index.cjs"
      }
    },
    "./utils": {
      "import": {
        "types": "./dist/utils.d.ts",
        "default": "./dist/utils.js"
      }
    }
  },
  "main": "./dist/index.cjs",
  "module": "./dist/index.js",
  "types": "./dist/index.d.ts"
}

// tsconfig.json
{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"],
      "@components/*": ["src/components/*"],
      "@utils/*": ["src/utils/*"],
      "@types/*": ["src/types/*"],
      "@lib/*": ["src/lib/*"],
      "@hooks/*": ["src/hooks/*"],
      "@services/*": ["src/services/*"],
      "@config": ["src/config/index.ts"]
    }
  }
}
 
// 使用例
import { Button } from "@components/Button";
import { formatDate } from "@utils/date";
import type { User } from "@types/user";
import { api } from "@lib/api";
import { useAuth } from "@hooks/useAuth";
import { UserService } from "@services/UserService";
import { config } from "@config";
 
// 注意: paths は型チェックのみ。実行時の解決には
// バンドラー設定（Vite: resolve.alias）や
// tsconfig-paths が別途必要

// Vite: vite.config.ts
import { defineConfig } from "vite";
import path from "path";
 
export default defineConfig({
  resolve: {
    alias: {
      "@": path.resolve(__dirname, "src"),
      "@components": path.resolve(__dirname, "src/components"),
      "@utils": path.resolve(__dirname, "src/utils"),
    },
  },
});
 
// webpack: webpack.config.js
module.exports = {
  resolve: {
    alias: {
      "@": path.resolve(__dirname, "src"),
      "@components": path.resolve(__dirname, "src/components"),
    },
    extensions: [".ts", ".tsx", ".js", ".jsx"],
  },
};
 
// Jest: jest.config.ts
const config = {
  moduleNameMapper: {
    "^@/(.*)$": "<rootDir>/src/$1",
    "^@components/(.*)$": "<rootDir>/src/components/$1",
  },
};
 
// Vitest: vitest.config.ts（vite.config.ts から自動取得）
// Vite の resolve.alias がそのまま使われる
 
// Node.js 直接実行: tsconfig-paths を使用
// node --import tsconfig-paths/register src/index.ts

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      // 複数のパスを指定すると、順番に解決を試みる
      "@shared/*": [
        "packages/shared/src/*",
        "packages/shared/dist/*"
      ],
      // ワイルドカードなしの完全一致
      "config": [
        "src/config/production.ts",
        "src/config/default.ts"
      ]
    }
  }
}

// packages/shared/tsconfig.json
{
  "compilerOptions": {
    "composite": true,
    "declaration": true,
    "declarationMap": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true
  },
  "include": ["src/**/*"]
}
 
// packages/frontend/tsconfig.json
{
  "compilerOptions": {
    "outDir": "./dist",
    "rootDir": "./src",
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "jsx": "react-jsx"
  },
  "references": [
    { "path": "../shared" }
  ],
  "include": ["src/**/*"]
}
 
// packages/backend/tsconfig.json
{
  "compilerOptions": {
    "outDir": "./dist",
    "rootDir": "./src",
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true
  },
  "references": [
    { "path": "../shared" }
  ],
  "include": ["src/**/*"]
}
 
// ルートの tsconfig.json（ソリューションファイル）
{
  "files": [],
  "references": [
    { "path": "packages/shared" },
    { "path": "packages/frontend" },
    { "path": "packages/backend" },
    { "path": "packages/e2e" }
  ]
}

# プロジェクト参照付きビルド（依存順に自動ビルド）
tsc --build
 
# ウォッチモード
tsc --build --watch
 
# クリーンビルド
tsc --build --clean
 
# verbose でビルド過程を確認
tsc --build --verbose
 
# 特定のパッケージのみビルド（依存も含む）
tsc --build packages/frontend
 
# 並列ビルドを強制（--build で自動的に並列化される場合がある）
tsc --build --force
 
# ドライラン（実際にはビルドしない）
tsc --build --dry

{
  "compilerOptions": {
    // 型定義ファイル(.d.ts)を出力
    "declaration": true,
 
    // .d.ts.map ファイルを出力（ソースへのジャンプ用）
    "declarationMap": true,
 
    // 型定義ファイルの出力先（outDir と分けたい場合）
    "declarationDir": "./types",
 
    // .js を出力せず .d.ts のみ出力
    "emitDeclarationOnly": true,
 
    // ソースマップを出力
    "sourceMap": true,
 
    // .js にインラインソースマップを埋め込む
    "inlineSourceMap": false,
 
    // ソースマップにソースコード自体を埋め込む
    "inlineSources": false
  }
}

{
  "compilerOptions": {
    // 出力先ディレクトリ
    "outDir": "./dist",
 
    // ソースのルートディレクトリ（出力の構造に影響）
    "rootDir": "./src",
 
    // 複数のルートディレクトリを指定
    "rootDirs": ["src", "generated"],
 
    // 単一ファイルに出力（module: "system" or "amd" の場合のみ）
    "outFile": "./dist/bundle.js",
 
    // BOM (Byte Order Mark) を出力に含めない
    "emitBOM": false,
 
    // ファイルを出力しない（型チェックのみ）
    "noEmit": true,
 
    // エラーがあっても出力する
    "noEmitOnError": true,
 
    // ヘルパー関数のインポートを使用（出力サイズ削減）
    "importHelpers": true,
 
    // ダウンレベル時のヘルパー関数をインライン化しない
    "noEmitHelpers": false,
 
    // 改行コード
    "newLine": "lf",
 
    // コメントを出力に含めない
    "removeComments": false,
 
    // 各ファイルを独立してトランスパイル
    "isolatedModules": true
  }
}

// isolatedModules: true の場合に禁止される構文
 
// 1. const enum のエクスポート（cross-file inlining が不可能）
// NG:
export const enum Direction {
  Up,
  Down,
  Left,
  Right,
}
 
// OK: 通常の enum を使用
export enum Direction {
  Up,
  Down,
  Left,
  Right,
}
 
// 2. 型のみの re-export
// NG:
import { User } from "./types";
export { User }; // User が型なのか値なのか不明
 
// OK: type キーワードを明示
import type { User } from "./types";
export type { User };
// もしくは
export { type User } from "./types";
 
// 3. 宣言だけのファイル（値のエクスポートがない）
// NG: このファイルには値のエクスポートがない
declare const x: number;
 
// OK: 何らかの値をエクスポート
export {};
declare const x: number;
 
// isolatedModules を有効にすべき理由:
// esbuild, SWC, Babel などのトランスパイラはファイル単位で変換するため
// cross-file の情報が必要な構文を使うとビルドが壊れる

// React 17+ (自動 JSX トランスフォーム)
{
  "compilerOptions": {
    "jsx": "react-jsx",
    "jsxImportSource": "react"
  }
}
 
// Preact
{
  "compilerOptions": {
    "jsx": "react-jsx",
    "jsxImportSource": "preact"
  }
}
 
// Solid.js（Vite で変換するため preserve）
{
  "compilerOptions": {
    "jsx": "preserve",
    "jsxImportSource": "solid-js"
  }
}
 
// Emotion CSS-in-JS
{
  "compilerOptions": {
    "jsx": "react-jsx",
    "jsxImportSource": "@emotion/react"
  }
}

{
  "compilerOptions": {
    // インクリメンタルビルドを有効化
    "incremental": true,
    // ビルド情報ファイルの保存先
    "tsBuildInfoFile": "./.tsbuildinfo"
  }
}

// パフォーマンス最適化設定
{
  "compilerOptions": {
    // .d.ts ファイルの型チェックをスキップ
    "skipLibCheck": true,
 
    // インクリメンタルビルド
    "incremental": true,
 
    // ファイルを出力しない（型チェックのみの場合）
    "noEmit": true,
 
    // import type の自動検出
    "verbatimModuleSyntax": true,
    // ↑ isolatedModules + preserveValueImports + importsNotUsedAsValues
    //   を1つのオプションで置き換え
  },
  // 対象ファイルを最小化
  "include": ["src/**/*"],
  "exclude": [
    "node_modules",
    "dist",
    "**/*.test.ts",
    "**/*.spec.ts",
    "**/__tests__/**"
  ]
}

# tsc のパフォーマンス診断
tsc --extendedDiagnostics
 
# 出力例:
# Files:           1234
# Lines:           89012
# Nodes:           345678
# Identifiers:     123456
# Symbols:         67890
# Types:           34567
# Instantiations:  234567
# Memory used:     456MB
# I/O Read:        0.12s
# Parse time:      1.23s
# Bind time:       0.45s
# Check time:      5.67s
# Emit time:       0.89s
# Total time:      8.36s
 
# traceResolution でモジュール解決をデバッグ
tsc --traceResolution > trace.txt 2>&1
 
# generateTrace でパフォーマンスプロファイルを生成
tsc --generateTrace ./trace-output
# Chrome の chrome://tracing で trace.json を開いて分析

# GitHub Actions での TypeScript ビルド最適化
name: TypeCheck
on: [push, pull_request]
 
jobs:
  typecheck:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'
 
      - run: npm ci
 
      # .tsbuildinfo のキャッシュ
      - uses: actions/cache@v4
        with:
          path: .tsbuildinfo
          key: tsbuildinfo-${{ hashFiles('tsconfig.json') }}-${{ github.sha }}
          restore-keys: |
            tsbuildinfo-${{ hashFiles('tsconfig.json') }}-
 
      # 型チェックのみ実行
      - run: tsc --noEmit --incremental

{
  "compilerOptions": {
    "target": "ES2017",
    "lib": ["dom", "dom.iterable", "esnext"],
    "allowJs": true,
    "skipLibCheck": true,
    "strict": true,
    "noEmit": true,
    "esModuleInterop": true,
    "module": "esnext",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "preserve",
    "incremental": true,
    "plugins": [{ "name": "next" }],
    "paths": { "@/*": ["./src/*"] }
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
  "exclude": ["node_modules"]
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "declaration": true,
    "sourceMap": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true,
    "verbatimModuleSyntax": true,
    "incremental": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

{
  "compilerOptions": {
    "target": "ES2022",
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "jsx": "react-jsx",
    "skipLibCheck": true,
    "noEmit": true,
    "isolatedModules": true,
    "verbatimModuleSyntax": true,
    "resolveJsonModule": true,
    "forceConsistentCasingInFileNames": true,
    "paths": {
      "@/*": ["./src/*"]
    }
  },
  "include": ["src/**/*", "vite-env.d.ts"],
  "exclude": ["node_modules"]
}

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "exactOptionalPropertyTypes": true,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "isolatedModules": true,
    "verbatimModuleSyntax": true,
    "noImplicitOverride": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist", "**/*.test.ts"]
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "noEmit": true,
    "lib": ["ES2022"],
    "types": ["@cloudflare/workers-types"],
    "isolatedModules": true,
    "verbatimModuleSyntax": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "jsx": "react-jsx"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "CommonJS",
    "moduleResolution": "node",
    "strict": true,
    "esModuleInterop": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "declaration": true,
    "sourceMap": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

// NG: strict を無効にして型安全性を放棄
{
  "compilerOptions": {
    "strict": false,
    "noImplicitAny": false
  }
}
// any が蔓延し、TypeScript を使う意味が薄れる
// バグの早期発見ができず、リファクタリングの安全性も損なわれる
 
// OK: 段階的に strict 化
{
  "compilerOptions": {
    "strict": true,
    // 移行中は個別に緩める
    "strictPropertyInitialization": false
  }
}

// NG: skipLibCheck を型チェック全体の無効化と勘違い
// skipLibCheck は .d.ts ファイルのチェックをスキップするだけ
// 自分のコードの型チェックには影響しない
 
// OK: skipLibCheck: true は推奨設定
// .d.ts 間の型衝突を回避し、ビルド速度が向上する
{
  "compilerOptions": {
    "skipLibCheck": true
  }
}
// 特に @types パッケージ間で型の衝突が起きた場合に有効
// 自分のコードの安全性は維持される

// NG: 旧式の moduleResolution を使用
{
  "compilerOptions": {
    "moduleResolution": "node"
  }
}
// package.json の "exports" フィールドをサポートしない
// ESM の正しい解決ができない
 
// OK: 用途に応じた最新の設定
// バンドラー使用時:
{
  "compilerOptions": {
    "moduleResolution": "bundler"
  }
}
// Node.js 直接実行時:
{
  "compilerOptions": {
    "moduleResolution": "NodeNext"
  }
}

// tsconfig.json で paths を設定
{
  "compilerOptions": {
    "paths": {
      "@/*": ["src/*"]
    }
  }
}
 
// NG: Vite の resolve.alias を設定し忘れる
// → 型チェックは通るが、実行時にモジュールが見つからない
 
// OK: 必ずバンドラー側にも同じエイリアスを設定
// vite.config.ts
import { defineConfig } from "vite";
import path from "path";
 
export default defineConfig({
  resolve: {
    alias: {
      "@": path.resolve(__dirname, "src"),
    },
  },
});

// NG: プロジェクト全体を include
{
  "include": ["**/*"]
}
// node_modules 以外の全ファイルがスキャンされ、パフォーマンス悪化
 
// OK: ソースディレクトリのみを指定
{
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()