// ECMAScript 標準デコレータ（Stage 3）
// TypeScript 5.0+ の experimentalDecorators: false（デフォルト）
 
// クラスデコレータ: クラス定義を受け取り、新しいクラスまたは void を返す
function sealed<T extends { new (...args: any[]): {} }>(
  target: T,
  context: ClassDecoratorContext
): T | void {
  console.log(`Sealing class: ${context.name}`);
  Object.seal(target);
  Object.seal(target.prototype);
  return target;
}
 
// ロギング機能を追加するデコレータ
function logged<T extends { new (...args: any[]): {} }>(
  target: T,
  context: ClassDecoratorContext
) {
  const className = String(context.name);
 
  return class extends target {
    constructor(...args: any[]) {
      console.log(`[${className}] Creating instance with args:`, args);
      super(...args);
      console.log(`[${className}] Instance created`);
    }
  };
}
 
// メソッドデコレータ: メソッドをラップして拡張
function log<T extends (...args: any[]) => any>(
  target: T,
  context: ClassMethodDecoratorContext
): T {
  const methodName = String(context.name);
 
  return function (this: any, ...args: any[]) {
    console.log(`Calling ${methodName} with`, args);
    const start = performance.now();
    const result = target.apply(this, args);
    const duration = performance.now() - start;
    console.log(`${methodName} returned`, result, `in ${duration.toFixed(2)}ms`);
    return result;
  } as T;
}
 
// 非同期メソッドデコレータ
function asyncLog<T extends (...args: any[]) => Promise<any>>(
  target: T,
  context: ClassMethodDecoratorContext
): T {
  const methodName = String(context.name);
 
  return async function (this: any, ...args: any[]) {
    console.log(`[Async] Calling ${methodName} with`, args);
    try {
      const result = await target.apply(this, args);
      console.log(`[Async] ${methodName} resolved with`, result);
      return result;
    } catch (error) {
      console.error(`[Async] ${methodName} rejected with`, error);
      throw error;
    }
  } as T;
}
 
// フィールドデコレータ: this を自動バインド
function bound<T extends (...args: any[]) => any>(
  _target: undefined,
  context: ClassFieldDecoratorContext
) {
  return function (this: any, value: T): T {
    return value.bind(this) as T;
  };
}
 
// アクセサデコレータ
function validate(
  target: any,
  context: ClassAccessorDecoratorContext | ClassSetterDecoratorContext
) {
  if (context.kind === "setter") {
    return function (this: any, value: any) {
      if (typeof value !== "string" || value.length === 0) {
        throw new Error(`Invalid value for ${String(context.name)}`);
      }
      target.call(this, value);
    };
  }
}
 
// 使用例
interface User {
  id: string;
  name: string;
}
 
@sealed
@logged
class UserService {
  private users: Map<string, User> = new Map();
 
  @log
  getUser(id: string): User | undefined {
    return this.users.get(id);
  }
 
  @asyncLog
  async fetchUser(id: string): Promise<User> {
    // 模擬的な非同期処理
    await new Promise((resolve) => setTimeout(resolve, 100));
    const user = this.users.get(id);
    if (!user) {
      throw new Error(`User ${id} not found`);
    }
    return user;
  }
 
  @bound
  handleClick = () => {
    // this が常にインスタンスにバインドされる
    console.log("UserService instance:", this);
  };
}
 
// 実行例
const service = new UserService();
// [UserService] Creating instance with args: []
// Sealing class: UserService
// [UserService] Instance created
 
service.getUser("user-1");
// Calling getUser with ['user-1']
// getUser returned undefined in 0.02ms
 
const button = { onClick: service.handleClick };
button.onClick(); // this は UserService のインスタンスを指す

// メタデータを使った依存性注入パターン
const METADATA_KEY = Symbol("metadata");
 
type Metadata = {
  injectable?: boolean;
  dependencies?: Function[];
  singleton?: boolean;
};
 
function Injectable(options: { singleton?: boolean } = {}) {
  return function <T extends { new (...args: any[]): {} }>(
    target: T,
    context: ClassDecoratorContext
  ) {
    // メタデータの追加（context.metadata を使用）
    context.metadata[METADATA_KEY] = {
      injectable: true,
      singleton: options.singleton ?? false,
    } as Metadata;
 
    return target;
  };
}
 
function Inject(dependency: Function) {
  return function (
    _target: undefined,
    context: ClassFieldDecoratorContext
  ) {
    const metadata = context.metadata[METADATA_KEY] as Metadata;
    if (!metadata.dependencies) {
      metadata.dependencies = [];
    }
    metadata.dependencies.push(dependency);
  };
}
 
@Injectable({ singleton: true })
class DatabaseService {
  connect() {
    console.log("Database connected");
  }
}
 
@Injectable()
class UserRepository {
  @Inject(DatabaseService)
  db!: DatabaseService;
 
  findAll() {
    this.db.connect();
    return ["user1", "user2"];
  }
}

// const 型パラメータの基本
 
// 通常のジェネリック: リテラル型が失われる
function identity<T>(value: T): T {
  return value;
}
const result1 = identity(["a", "b", "c"]);
// 型: string[]（リテラル型が失われる）
 
// const 型パラメータ: リテラル型が保持される
function identityConst<const T>(value: T): T {
  return value;
}
const result2 = identityConst(["a", "b", "c"]);
// 型: readonly ["a", "b", "c"]（リテラル型が保持される）

// const 型パラメータを使った型安全なルーター実装
 
type RouteConfig<T> = {
  readonly path: string;
  readonly handler: () => T;
};
 
type Router<T extends Record<string, RouteConfig<any>>> = {
  readonly routes: T;
  navigate<K extends keyof T>(path: K): ReturnType<T[K]["handler"]>;
  getPaths(): ReadonlyArray<keyof T>;
};
 
function createRouter<const T extends Record<string, RouteConfig<any>>>(
  routes: T
): Router<T> {
  return {
    routes,
    navigate(path) {
      const route = routes[path];
      if (!route) {
        throw new Error(`Route ${String(path)} not found`);
      }
      return route.handler();
    },
    getPaths() {
      return Object.keys(routes) as Array<keyof T>;
    },
  };
}
 
// 使用例
const router = createRouter({
  "/home": {
    path: "/home",
    handler: () => ({ page: "home", title: "Home Page" }),
  },
  "/about": {
    path: "/about",
    handler: () => ({ page: "about", version: 2 }),
  },
  "/contact": {
    path: "/contact",
    handler: () => ({ page: "contact", email: "info@example.com" }),
  },
});
 
// 型安全なナビゲーション
const homeResult = router.navigate("/home");
// 型: { page: string; title: string }
 
const aboutResult = router.navigate("/about");
// 型: { page: string; version: number }
 
// @ts-expect-error: 存在しないパス
router.navigate("/unknown");
 
// パスの一覧を取得
const paths = router.getPaths();
// 型: readonly ("/home" | "/about" | "/contact")[]

// const 型パラメータと satisfies を組み合わせた高度なパターン
 
type Action = {
  type: string;
  payload?: unknown;
};
 
type ActionMap = Record<string, Action>;
 
function createActions<const T extends ActionMap>(actions: T): T {
  return actions;
}
 
// 使用例: Redux-like なアクション定義
const actions = createActions({
  INCREMENT: { type: "INCREMENT" },
  DECREMENT: { type: "DECREMENT" },
  SET_VALUE: { type: "SET_VALUE", payload: 0 },
} satisfies ActionMap);
 
// 型: {
//   readonly INCREMENT: { type: "INCREMENT" };
//   readonly DECREMENT: { type: "DECREMENT" };
//   readonly SET_VALUE: { type: "SET_VALUE"; payload: number };
// }
 
type ActionsType = typeof actions;
type ActionTypes = ActionsType[keyof ActionsType];
// ActionTypes =
//   | { type: "INCREMENT" }
//   | { type: "DECREMENT" }
//   | { type: "SET_VALUE"; payload: number }
 
function reducer(state: number, action: ActionTypes): number {
  switch (action.type) {
    case "INCREMENT":
      return state + 1;
    case "DECREMENT":
      return state - 1;
    case "SET_VALUE":
      // action.payload の型が number と推論される
      return action.payload;
    default:
      return state;
  }
}

// enum の改善: union 型との統一性向上
 
enum Color {
  Red = "red",
  Green = "green",
  Blue = "blue",
}
 
// 5.0 以前: この代入はエラーになることがあった
const colors: Color[] = ["red", "green", "blue"] as Color[];
 
// 5.0 以降: より柔軟に扱える
type ColorValue = `${Color}`;
const colorValue: ColorValue = "red"; // OK
 
// enum の値から union 型を生成
type ColorUnion = Color.Red | Color.Green | Color.Blue;
 
function processColor(color: ColorUnion): void {
  console.log(color);
}
 
processColor(Color.Red); // OK
processColor("red" as Color.Red); // OK

// getter と setter で異なる型を使用可能に
 
class Resource {
  private _value: string | undefined;
 
  // getter は non-null な string を返す
  get value(): string {
    if (this._value === undefined) {
      throw new Error("Value not initialized");
    }
    return this._value;
  }
 
  // setter は string | undefined を受け付ける
  set value(val: string | undefined) {
    this._value = val;
  }
}
 
const r = new Resource();
r.value = "hello";         // setter: string | undefined を受け付ける
const v: string = r.value; // getter: string を返す（undefined でない）
r.value = undefined;       // OK: setter は undefined を受け付ける
 
// r.value を読むと string が返る（undefined を投げる可能性がある）

// Lazy Initialization with getter/setter type asymmetry
 
class LazyValue<T> {
  private _value: T | undefined;
  private _initializer: () => T;
 
  constructor(initializer: () => T) {
    this._initializer = initializer;
  }
 
  // getter: 必ず T を返す（初期化されていなければ初期化）
  get value(): T {
    if (this._value === undefined) {
      console.log("Initializing lazy value...");
      this._value = this._initializer();
    }
    return this._value;
  }
 
  // setter: T | undefined を受け付ける（リセット可能）
  set value(val: T | undefined) {
    this._value = val;
  }
 
  reset(): void {
    this._value = undefined;
  }
}
 
// 使用例
const expensiveComputation = new LazyValue(() => {
  console.log("Computing...");
  return Array.from({ length: 1000000 }, (_, i) => i).reduce((a, b) => a + b, 0);
});
 
console.log("Before access");
const result = expensiveComputation.value; // "Initializing lazy value..." → "Computing..."
console.log(result); // 499999500000
const cachedResult = expensiveComputation.value; // "Computing..." は表示されない（キャッシュされている）
 
expensiveComputation.reset();
const recomputed = expensiveComputation.value; // 再度 "Computing..." が表示される

// 型変換を伴う getter/setter パターン
 
class TemperatureConverter {
  private _celsius: number = 0;
 
  // Celsius で保持、Fahrenheit で取得
  get fahrenheit(): number {
    return (this._celsius * 9) / 5 + 32;
  }
 
  set fahrenheit(f: number) {
    this._celsius = ((f - 32) * 5) / 9;
  }
 
  get celsius(): number {
    return this._celsius;
  }
 
  set celsius(c: number) {
    this._celsius = c;
  }
}
 
const temp = new TemperatureConverter();
temp.celsius = 0;
console.log(temp.fahrenheit); // 32
 
temp.fahrenheit = 100;
console.log(temp.celsius); // 37.77777777777778

// 暗黙的な undefined 返り値の改善
 
// 5.1 以前: return undefined が必須
function findUser(id: string): User | undefined {
  const user = database.get(id);
  if (!user) {
    return undefined; // 明示的に必要だった
  }
  return user;
}
 
// 5.1 以降: return を省略可能
function findUser2(id: string): User | undefined {
  const user = database.get(id);
  if (!user) {
    return; // undefined が暗黙的に返される
  }
  return user;
}
 
// より自然な記述が可能に
function getConfig(key: string): string | undefined {
  if (key === "port") return "3000";
  if (key === "host") return "localhost";
  // 暗黙的に undefined が返される
}

// Disposable インターフェースの実装
 
class FileHandle implements Disposable {
  private handle: number | null = null;
  private path: string;
 
  constructor(path: string) {
    this.path = path;
    this.handle = this.openFileSync(path);
    console.log(`Opened: ${path}`);
  }
 
  private openFileSync(path: string): number {
    // 模擬的なファイルハンドル
    return Math.floor(Math.random() * 1000);
  }
 
  read(): string {
    if (this.handle === null) {
      throw new Error("File is closed");
    }
    return `Content of ${this.path}`;
  }
 
  write(content: string): void {
    if (this.handle === null) {
      throw new Error("File is closed");
    }
    console.log(`Writing to ${this.path}:`, content);
  }
 
  [Symbol.dispose](): void {
    if (this.handle !== null) {
      console.log(`Closing file: ${this.path}`);
      this.handle = null;
    }
  }
}
 
// using で自動リソース解放
function processFile(path: string): string {
  using file = new FileHandle(path);
  const content = file.read();
  file.write("Updated content");
  return content;
  // スコープ終了時に自動で [Symbol.dispose]() が呼ばれる
}
 
// 実行例
const result = processFile("data.txt");
// Opened: data.txt
// Writing to data.txt: Updated content
// Closing file: data.txt

// AsyncDisposable インターフェース
 
class DatabaseConnection implements AsyncDisposable {
  private connected: boolean = false;
  private url: string;
 
  private constructor(url: string) {
    this.url = url;
  }
 
  static async create(url: string): Promise<DatabaseConnection> {
    const conn = new DatabaseConnection(url);
    await conn.connect();
    return conn;
  }
 
  private async connect(): Promise<void> {
    console.log(`Connecting to ${this.url}...`);
    await new Promise((resolve) => setTimeout(resolve, 100));
    this.connected = true;
    console.log("Connected!");
  }
 
  async query<T>(sql: string): Promise<T[]> {
    if (!this.connected) {
      throw new Error("Not connected");
    }
    console.log(`Executing query: ${sql}`);
    await new Promise((resolve) => setTimeout(resolve, 50));
    return [] as T[];
  }
 
  async [Symbol.asyncDispose](): Promise<void> {
    if (this.connected) {
      console.log("Disconnecting from database...");
      await new Promise((resolve) => setTimeout(resolve, 50));
      this.connected = false;
      console.log("Disconnected!");
    }
  }
}
 
// await using で自動リソース解放
async function queryUsers(): Promise<User[]> {
  await using db = await DatabaseConnection.create("postgresql://localhost:5432/mydb");
  const users = await db.query<User>("SELECT * FROM users");
  return users;
  // 自動的に await db[Symbol.asyncDispose]() が呼ばれる
}
 
// 実行例
await queryUsers();
// Connecting to postgresql://localhost:5432/mydb...
// Connected!
// Executing query: SELECT * FROM users
// Disconnecting from database...
// Disconnected!

// using のエラーハンドリングと SuppressedError
 
class Transaction implements Disposable {
  private committed: boolean = false;
 
  commit(): void {
    console.log("Committing transaction...");
    this.committed = true;
  }
 
  [Symbol.dispose](): void {
    if (!this.committed) {
      console.log("Rolling back transaction...");
      // ロールバック処理
    }
  }
}
 
function processTransaction(shouldFail: boolean): void {
  using tx = new Transaction();
 
  if (shouldFail) {
    throw new Error("Transaction failed");
  }
 
  tx.commit();
}
 
try {
  processTransaction(true);
} catch (error) {
  console.error("Error:", error);
  // 先に tx[Symbol.dispose]() が呼ばれ、その後エラーが投げられる
}
// Rolling back transaction...
// Error: Error: Transaction failed
 
// dispose 中にもエラーが発生した場合
class ProblematicResource implements Disposable {
  [Symbol.dispose](): void {
    throw new Error("Dispose failed");
  }
}
 
function useProblematicResource(): void {
  using resource = new ProblematicResource();
  throw new Error("Operation failed");
}
 
try {
  useProblematicResource();
} catch (error) {
  console.error(error);
  // SuppressedError が投げられる（元のエラーと dispose のエラーを両方含む）
}

// デコレータメタデータの活用
 
type MetadataMap = {
  validation?: {
    required?: boolean;
    minLength?: number;
    maxLength?: number;
  };
  serialization?: {
    name?: string;
    ignore?: boolean;
  };
};
 
function Required() {
  return function (
    _target: undefined,
    context: ClassFieldDecoratorContext
  ) {
    const metadata = context.metadata as MetadataMap;
    if (!metadata.validation) {
      metadata.validation = {};
    }
    metadata.validation.required = true;
  };
}
 
function MinLength(length: number) {
  return function (
    _target: undefined,
    context: ClassFieldDecoratorContext
  ) {
    const metadata = context.metadata as MetadataMap;
    if (!metadata.validation) {
      metadata.validation = {};
    }
    metadata.validation.minLength = length;
  };
}
 
function SerializedName(name: string) {
  return function (
    _target: undefined,
    context: ClassFieldDecoratorContext
  ) {
    const metadata = context.metadata as MetadataMap;
    if (!metadata.serialization) {
      metadata.serialization = {};
    }
    metadata.serialization.name = name;
  };
}
 
class UserDto {
  @Required()
  @MinLength(3)
  @SerializedName("user_name")
  username!: string;
 
  @Required()
  email!: string;
}
 
// メタデータを使ったバリデーション関数
function validate<T extends object>(obj: T): boolean {
  const metadata = (obj.constructor as any)[Symbol.metadata] as MetadataMap;
  // メタデータを使った検証ロジック
  return true;
}

// Import Attributes（旧称: Import Assertions）
 
// JSON のインポート
import config from "./config.json" with { type: "json" };
// config の型が自動的に推論される
 
// CSS のインポート（CSS Modules）
import styles from "./app.css" with { type: "css" };
 
// 動的インポート
const data = await import("./data.json", {
  with: { type: "json" },
});
 
// カスタム属性
import wasmModule from "./module.wasm" with { type: "webassembly" };
 
// 型定義の例
// config.json
{
  "port": 3000,
  "host": "localhost",
  "debug": true
}
 
// TypeScript が自動推論する型:
// type Config = {
//   port: number;
//   host: string;
//   debug: boolean;
// }

// Import Attributes を使った設定管理
 
// config/development.json
import devConfig from "./config/development.json" with { type: "json" };
 
// config/production.json
import prodConfig from "./config/production.json" with { type: "json" };
 
type Config = {
  database: {
    host: string;
    port: number;
    name: string;
  };
  api: {
    baseUrl: string;
    timeout: number;
  };
  features: {
    enableAnalytics: boolean;
    enableDebug: boolean;
  };
};
 
function getConfig(): Config {
  const env = process.env.NODE_ENV || "development";
 
  switch (env) {
    case "production":
      return prodConfig;
    case "development":
    default:
      return devConfig;
  }
}
 
export const config = getConfig();

// switch (true) の型絞り込み（5.3 の改善）
 
function classify(value: string | number | boolean | null): string {
  switch (true) {
    case value === null:
      // value は null に絞り込まれる
      return "null value";
 
    case typeof value === "string":
      // value は string に絞り込まれる
      return value.toUpperCase();
 
    case typeof value === "number":
      // value は number に絞り込まれる
      return value.toFixed(2);
 
    case typeof value === "boolean":
      // value は boolean に絞り込まれる
      return value ? "yes" : "no";
 
    default:
      const _exhaustive: never = value;
      return _exhaustive;
  }
}
 
// より複雑な条件での絞り込み
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };
 
function getArea(shape: Shape): number {
  switch (true) {
    case shape.kind === "circle":
      // shape は { kind: "circle"; radius: number } に絞り込まれる
      return Math.PI * shape.radius ** 2;
 
    case shape.kind === "rectangle":
      // shape は { kind: "rectangle"; width: number; height: number } に絞り込まれる
      return shape.width * shape.height;
 
    case shape.kind === "triangle":
      // shape は { kind: "triangle"; base: number; height: number } に絞り込まれる
      return (shape.base * shape.height) / 2;
 
    default:
      const _exhaustive: never = shape;
      return _exhaustive;
  }
}

// インライン型ナローイングの改善
 
type Response<T> =
  | { success: true; data: T }
  | { success: false; error: string };
 
async function fetchUser(id: string): Promise<Response<User>> {
  try {
    const user = await api.getUser(id);
    return { success: true, data: user };
  } catch (error) {
    return { success: false, error: String(error) };
  }
}
 
// 5.3 の改善: インライン条件での絞り込み
async function processUser(id: string): Promise<void> {
  const response = await fetchUser(id);
 
  // 5.3 以降: response.success の確認で型が絞り込まれる
  if (response.success) {
    // response は { success: true; data: User } に絞り込まれる
    console.log(response.data.name);
  } else {
    // response は { success: false; error: string } に絞り込まれる
    console.error(response.error);
  }
 
  // 三項演算子内でも絞り込みが機能
  const message = response.success
    ? `User: ${response.data.name}`  // data が利用可能
    : `Error: ${response.error}`;    // error が利用可能
}

// NoInfer: 型推論の候補から除外
 
// NoInfer なし: defaultValue からも T が推論される
function getOrDefault<T>(
  value: T | null | undefined,
  defaultValue: T
): T {
  return value ?? defaultValue;
}
 
const result1 = getOrDefault("hello", 42);
// T は string | number に推論される（望ましくない）
 
// NoInfer あり: defaultValue からは T を推論しない
function getOrDefaultFixed<T>(
  value: T | null | undefined,
  defaultValue: NoInfer<T>
): T {
  return value ?? defaultValue;
}
 
const result2 = getOrDefaultFixed("hello", 42);
// エラー: number は string に代入不可
// T は "hello" の型 string からのみ推論される
 
const result3 = getOrDefaultFixed("hello", "world");
// OK: T は string に推論され、defaultValue も string

// NoInfer を使った型安全な API
 
// ダメな例: 両方の引数から型が推論される
function createPair<T>(first: T, second: T): [T, T] {
  return [first, second];
}
 
const pair1 = createPair(1, "hello");
// T は number | string に推論される（望ましくない）
// pair1 の型: [number | string, number | string]
 
// 良い例: 最初の引数からのみ型を推論
function createPairFixed<T>(first: T, second: NoInfer<T>): [T, T] {
  return [first, second];
}
 
const pair2 = createPairFixed(1, "hello");
// エラー: string は number に代入不可
 
const pair3 = createPairFixed(1, 2);
// OK: pair3 の型は [number, number]
 
// 実践的な使用例: イベントハンドラー
type EventMap = {
  click: { x: number; y: number };
  keypress: { key: string };
  submit: { data: FormData };
};
 
function addEventListener<K extends keyof EventMap>(
  event: K,
  handler: (payload: NoInfer<EventMap[K]>) => void
): void {
  // イベントリスナーの登録
}
 
// K が event から推論され、handler の型がそれに従う
addEventListener("click", (payload) => {
  console.log(payload.x, payload.y); // OK
});
 
addEventListener("keypress", (payload) => {
  console.log(payload.key); // OK
  // @ts-expect-error: x は keypress にない
  console.log(payload.x);
});

// NoInfer を使ったデフォルト値パターン
 
type Options<T> = {
  value: T;
  fallback?: NoInfer<T>;
  transform?: (val: T) => NoInfer<T>;
};
 
function process<T>(options: Options<T>): T {
  const { value, fallback, transform } = options;
  const processed = transform ? transform(value) : value;
  return processed ?? fallback ?? value;
}
 
// 使用例
const result = process({
  value: "hello",
  fallback: "default", // OK: string
  transform: (s) => s.toUpperCase(), // OK: (string) => string
});
 
const invalid = process({
  value: "hello",
  fallback: 123, // エラー: number は string に代入不可
});

// クロージャでの型絞り込み保持
 
function processValue(value: string | number) {
  if (typeof value === "string") {
    // 5.4 以前: クロージャ内で value は string | number に戻る
    // 5.4 以降: value は string のまま保持される
 
    const fn = () => {
      return value.toUpperCase(); // OK in 5.4+
    };
 
    return fn();
  } else {
    const fn = () => {
      return value.toFixed(2); // OK: value は number
    };
 
    return fn();
  }
}
 
// より複雑な例
type User = { type: "user"; name: string; email: string };
type Admin = { type: "admin"; name: string; permissions: string[] };
type Person = User | Admin;
 
function processPerson(person: Person): void {
  if (person.type === "admin") {
    // person は Admin に絞り込まれる
 
    const logPermissions = () => {
      // 5.4+: person.permissions にアクセス可能
      console.log(person.permissions.join(", "));
    };
 
    logPermissions();
 
    // 非同期関数内でも保持される
    setTimeout(() => {
      console.log(person.permissions); // OK
    }, 1000);
  }
}

// 配列メソッドとクロージャの組み合わせ
 
type Item = { id: number; name: string; category?: string };
 
function filterAndMap(items: Item[]): string[] {
  // filter で category が存在するものだけを抽出
  return items
    .filter((item) => item.category !== undefined)
    .map((item) => {
      // 5.4+: item.category は string に絞り込まれている
      return item.category.toUpperCase();
    });
}
 
// より複雑な例
function processItems(items: (string | number)[]): void {
  items.forEach((item) => {
    if (typeof item === "string") {
      // item は string に絞り込まれる
 
      const delayed = () => {
        // 5.4+: item は string のまま
        console.log(item.toUpperCase());
      };
 
      setTimeout(delayed, 100);
    }
  });
}

// 型述語の自動推論
 
// 5.5 以前: 明示的な型述語が必要
function isNonNullOld<T>(value: T | null | undefined): value is T {
  return value != null;
}
 
// 5.5 以降: 自動推論される
const isNonNull = <T>(value: T | null | undefined) => value != null;
// 推論される型: <T>(value: T | null | undefined) => value is T
 
const values = [1, null, 2, undefined, 3];
const filtered = values.filter(isNonNull);
// 5.5+: filtered の型は number[]
// 5.4 以前: filtered の型は (number | null | undefined)[]
 
// より複雑な例
const isUser = (value: unknown) =>
  typeof value === "object" &&
  value !== null &&
  "id" in value &&
  "name" in value;
// 自動推論: (value: unknown) => value is { id: unknown; name: unknown }
 
interface User {
  id: number;
  name: string;
  email: string;
}
 
const users: unknown[] = await fetchData();
const validUsers = users.filter(isUser);
// validUsers の型: { id: unknown; name: unknown }[]

// filter と型述語の自動推論
 
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };
 
const shapes: Shape[] = [
  { kind: "circle", radius: 5 },
  { kind: "rectangle", width: 10, height: 20 },
  { kind: "triangle", base: 8, height: 12 },
];
 
// 5.5: 型述語が自動推論される
const circles = shapes.filter((s) => s.kind === "circle");
// circles の型: { kind: "circle"; radius: number }[]
 
const rectangles = shapes.filter((s) => s.kind === "rectangle");
// rectangles の型: { kind: "rectangle"; width: number; height: number }[]
 
// 複数条件の組み合わせ
const bigShapes = shapes.filter((s) => {
  if (s.kind === "circle") return s.radius > 10;
  if (s.kind === "rectangle") return s.width > 10 || s.height > 10;
  return s.base > 10;
});
// bigShapes の型: Shape[]（型は絞り込まれない）

// カスタム型ガードの簡略化
 
// 5.5 以前: 明示的な型述語
function isErrorOld(value: unknown): value is Error {
  return value instanceof Error;
}
 
// 5.5 以降: 自動推論
const isError = (value: unknown) => value instanceof Error;
// 推論される型: (value: unknown) => value is Error
 
// 配列の型ガード
const isStringArray = (value: unknown) =>
  Array.isArray(value) && value.every((item) => typeof item === "string");
// 推論される型: (value: unknown) => value is string[]
 
const data: unknown = JSON.parse('["a", "b", "c"]');
if (isStringArray(data)) {
  // data は string[] に絞り込まれる
  data.forEach((s) => console.log(s.toUpperCase()));
}

// 正規表現の型チェック
 
// OK: 正しい正規表現
const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/;
const phoneRegex = /^\+?[1-9]\d{1,14}$/;
const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
// エラー: 閉じ括弧がない
// @ts-expect-error
const invalidRegex1 = /[unclosed/;
 
// エラー: 不正なエスケープシーケンス
// @ts-expect-error
const invalidRegex2 = /\k/;
 
// OK: 名前付きキャプチャグループ
const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
 
// OK: 後方参照
const duplicateRegex = /(\w+)\s+\1/;
 
// OK: Unicode プロパティエスケープ
const emojiRegex = /\p{Emoji}/u;

// 正規表現を使ったバリデーション
 
type Validator<T extends string> = {
  pattern: RegExp;
  validate: (value: string) => value is T;
  format: (value: T) => string;
};
 
// Email バリデーター
const emailValidator: Validator<`${string}@${string}.${string}`> = {
  pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
  validate: (value): value is `${string}@${string}.${string}` => {
    return emailValidator.pattern.test(value);
  },
  format: (value) => value.toLowerCase(),
};
 
// URL バリデーター
const urlValidator: Validator<`https://${string}` | `http://${string}`> = {
  pattern: /^https?:\/\/.+$/,
  validate: (value): value is `https://${string}` | `http://${string}` => {
    return urlValidator.pattern.test(value);
  },
  format: (value) => value,
};
 
// 使用例
const email = "user@example.com";
if (emailValidator.validate(email)) {
  // email は `${string}@${string}.${string}` 型
  const formatted = emailValidator.format(email);
}
 
const url = "https://example.com";
if (urlValidator.validate(url)) {
  // url は `https://${string}` | `http://${string}` 型
  const formatted = urlValidator.format(url);
}

// isolatedDeclarations の有効化
// tsconfig.json
{
  "compilerOptions": {
    "isolatedDeclarations": true,
    "declaration": true
  }
}
 
// isolatedDeclarations 有効時: 戻り値の型を明示する必要がある
 
// NG: 戻り値の型が明示されていない
export function getUser(id: string) {
  return { id, name: "Alice" };
}
 
// OK: 戻り値の型を明示
export function getUser(id: string): { id: string; name: string } {
  return { id, name: "Alice" };
}
 
// または型エイリアスを使用
type UserData = { id: string; name: string };
 
export function getUser(id: string): UserData {
  return { id, name: "Alice" };
}
 
// ジェネリック関数でも同様
// NG
export function map<T, U>(arr: T[], fn: (item: T) => U) {
  return arr.map(fn);
}
 
// OK
export function map<T, U>(arr: T[], fn: (item: T) => U): U[] {
  return arr.map(fn);
}

// Iterator ヘルパーメソッド（TC39 Stage 3）
 
function* fibonacci(): Generator<number> {
  let [a, b] = [0, 1];
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}
 
const fib = fibonacci();
 
// .take() -- 最初の N 個を取得
const first10 = fib.take(10);
// 型: IteratorObject<number, void, undefined>
 
// .map() -- 各要素を変換
const doubled = fib.take(10).map((n) => n * 2);
// 型: IteratorObject<number, void, undefined>
 
// .filter() -- フィルタリング
const evens = fib.take(20).filter((n) => n % 2 === 0);
// 型: IteratorObject<number, void, undefined>
 
// .toArray() -- 配列に変換
const array = fib.take(10).toArray();
// 型: number[]
 
// チェーン可能
const result = fib
  .take(100)
  .filter((n) => n % 2 === 0)
  .map((n) => n * 2)
  .take(10)
  .toArray();
// result: number[] = [0, 4, 8, 16, 24, 40, 56, 88, 136, 216]

// Iterator ヘルパーを使ったデータ処理
 
function* range(start: number, end: number, step: number = 1): Generator<number> {
  for (let i = start; i < end; i += step) {
    yield i;
  }
}
 
// 1 から 100 までの奇数の二乗
const oddSquares = range(1, 100)
  .filter((n) => n % 2 === 1)
  .map((n) => n ** 2)
  .toArray();
// [1, 9, 25, 49, 81, ...]
 
// 無限ストリーム処理
function* naturals(): Generator<number> {
  let n = 1;
  while (true) {
    yield n++;
  }
}
 
const first20Primes = naturals()
  .filter((n) => {
    if (n < 2) return false;
    for (let i = 2; i <= Math.sqrt(n); i++) {
      if (n % i === 0) return false;
    }
    return true;
  })
  .take(20)
  .toArray();
// [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]
 
// ファイル行の遅延処理
async function* readLines(path: string): AsyncGenerator<string> {
  const file = await openFile(path);
  try {
    for await (const line of file) {
      yield line;
    }
  } finally {
    await file.close();
  }
}
 
// 非同期 Iterator ヘルパー
const longLines = await readLines("data.txt")
  .filter((line) => line.length > 100)
  .map((line) => line.trim())
  .take(10)
  .toArray();

// Disallowed Nullish/Truthy Checks
 
// エラー: この条件は常に true
const value = "hello";
if (value) {
  // 警告: value は常に truthy
}
 
// エラー: この条件は常に false
const num = 42;
if (!num) {
  // 警告: num は常に truthy
}
 
// エラー: nullish coalescing が不要
const str = "hello";
const result = str ?? "default";
// 警告: str は常に non-nullish
 
// OK: nullable な値
const nullable: string | null = getValue();
if (nullable) {
  // 問題なし
}
 
const withDefault = nullable ?? "default";
// 問題なし
 
// 関数パラメータの場合
function process(value: string): void {
  // エラー: value は常に truthy（undefined/null でない）
  if (value) {
    console.log(value);
  }
 
  // OK: 空文字列チェック
  if (value.length > 0) {
    console.log(value);
  }
}
 
// オプショナルパラメータは OK
function processOptional(value?: string): void {
  // OK: value は string | undefined
  if (value) {
    console.log(value);
  }
}

// Disallowed Nullish/Truthy Checks の修正例
 
// NG: 不要な nullish チェック
function getUserName(user: User): string {
  return user.name ?? "Anonymous";
  // 警告: user.name は string 型なので ?? は不要
}
 
// OK: 修正版
function getUserName(user: User): string {
  return user.name || "Anonymous"; // 空文字列もカバーする場合
  // または
  return user.name.length > 0 ? user.name : "Anonymous";
}
 
// NG: 常に真の条件
function isValid(config: Config): boolean {
  if (config) {
    // 警告: config は常に truthy
    return true;
  }
  return false;
}
 
// OK: 修正版（適切なプロパティチェック）
function isValid(config: Config): boolean {
  return config.apiKey.length > 0 && config.endpoint.length > 0;
}

// 副作用のみのインポートのチェック
// tsconfig.json
{
  "compilerOptions": {
    "noUncheckedSideEffectImports": true
  }
}
 
// エラー: モジュールが存在しない
import "./nonexistent-module";
 
// OK: node_modules に存在
import "reflect-metadata";
 
// OK: ファイルが存在
import "./setup.js";
 
// OK: package.json の sideEffects フィールドに記載
import "polyfills";
 
// 実践例
// setup.ts（副作用のみのモジュール）
console.log("Initializing application...");
 
// polyfills.ts
if (!Array.prototype.at) {
  Array.prototype.at = function (index: number) {
    if (index < 0) {
      return this[this.length + index];
    }
    return this[index];
  };
}
 
// main.ts
import "./setup"; // OK: setup.ts が存在
import "./polyfills"; // OK: polyfills.ts が存在

// TypeScript 5.7 のパフォーマンス改善
 
// 大規模な union 型の処理が高速化
type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
type StatusCode = 200 | 201 | 204 | 400 | 401 | 403 | 404 | 500 | 502 | 503;
type ContentType = "application/json" | "text/html" | "text/plain" | "application/xml";
 
type Response = {
  method: HttpMethod;
  status: StatusCode;
  contentType: ContentType;
  body: unknown;
};
 
// 5.7 では、このような複雑な型の推論が高速化されている
 
// mapped types の最適化
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};
 
type ComplexObject = {
  users: {
    id: number;
    profile: {
      name: string;
      settings: {
        theme: string;
        notifications: boolean;
      };
    };
  }[];
};
 
type ReadonlyComplex = DeepReadonly<ComplexObject>;
// 5.7 では処理が高速化

// --erasableSyntaxOnly フラグ（5.7 の実験的機能）
// tsconfig.json
{
  "compilerOptions": {
    "erasableSyntaxOnly": true
  }
}
 
// このフラグを有効にすると、トランスパイル時に削除可能な構文のみを使用できる
 
// OK: 型アノテーションは削除可能
const name: string = "Alice";
 
// OK: インターフェース定義は削除可能
interface User {
  id: number;
  name: string;
}
 
// NG: enum は JavaScript コードを生成するため不可
enum Color {
  Red,
  Green,
  Blue,
}
 
// OK の代替: const オブジェクトまたは union 型を使用
const Color = {
  Red: "red",
  Green: "green",
  Blue: "blue",
} as const;
 
type ColorValue = typeof Color[keyof typeof Color];
 
// NG: namespace は JavaScript コードを生成
namespace Utils {
  export function log(message: string) {
    console.log(message);
  }
}
 
// OK の代替: 通常のモジュールを使用
export function log(message: string) {
  console.log(message);
}

// Node.js 22 の新機能サポート
 
// AsyncLocalStorage の型改善
import { AsyncLocalStorage } from "async_hooks";
 
const storage = new AsyncLocalStorage<{ requestId: string }>();
 
async function handleRequest(requestId: string) {
  await storage.run({ requestId }, async () => {
    // storage.getStore() の型が正しく推論される
    const context = storage.getStore();
    if (context) {
      console.log(`Request ID: ${context.requestId}`);
    }
  });
}
 
// Import Attributes のネイティブサポート
import packageJson from "./package.json" with { type: "json" };
// Node.js 22 では --experimental-json-modules フラグが不要
 
// 新しい Array メソッドの型定義
const numbers = [1, 2, 3, 4, 5];
 
// Array.prototype.toReversed()
const reversed = numbers.toReversed();
// 型: number[]（元の配列は変更されない）
 
// Array.prototype.toSorted()
const sorted = numbers.toSorted((a, b) => b - a);
// 型: number[]
 
// Array.prototype.toSpliced()
const spliced = numbers.toSpliced(2, 1, 10);
// 型: number[]
 
// Array.prototype.with()
const replaced = numbers.with(2, 100);
// 型: number[]

// 5.0 へのマイグレーション
 
// ステップ 1: experimentalDecorators の確認
// tsconfig.json
{
  "compilerOptions": {
    // 旧式デコレータを使っている場合は true のまま
    "experimentalDecorators": true,
    // または、新しいデコレータに移行
    "experimentalDecorators": false
  }
}
 
// ステップ 2: enum の使用箇所を確認
// 5.0 で enum の振る舞いが変更された場合がある
enum Status {
  Pending = "PENDING",
  Success = "SUCCESS",
  Error = "ERROR",
}
 
// union 型への移行を検討
type Status = "PENDING" | "SUCCESS" | "ERROR";
 
// ステップ 3: const 型パラメータの活用
// Before
function createConfig<T>(config: T) {
  return config;
}
 
// After
function createConfig<const T>(config: T) {
  return config;
}

// 5.2 へのマイグレーション: using 宣言の導入
 
// Before: 手動でのリソース管理
async function processData() {
  const db = await connectToDatabase();
  try {
    const result = await db.query("SELECT * FROM users");
    return result;
  } finally {
    await db.disconnect();
  }
}
 
// After: using 宣言を使用
async function processData() {
  await using db = await DatabaseConnection.create(process.env.DB_URL!);
  const result = await db.query("SELECT * FROM users");
  return result;
  // 自動的に disconnect される
}
 
// AsyncDisposable の実装
class DatabaseConnection implements AsyncDisposable {
  static async create(url: string): Promise<DatabaseConnection> {
    const conn = new DatabaseConnection();
    await conn.connect(url);
    return conn;
  }
 
  async [Symbol.asyncDispose](): Promise<void> {
    await this.disconnect();
  }
 
  private async connect(url: string): Promise<void> { /* ... */ }
  private async disconnect(): Promise<void> { /* ... */ }
  async query(sql: string): Promise<any[]> { /* ... */ }
}