第5章: 型システムの応用 — ジェネリクス・条件型・テンプレートリテラル型

// ジェネリクスなし — 型安全性が失われる
function firstElement(arr: any[]): any {
  return arr[0];
}

// ジェネリクスあり — 型安全性を保持
function firstElement<T>(arr: T[]): T | undefined {
  return arr[0];
}

const num = firstElement([1, 2, 3]);      // number | undefined
const str = firstElement(["a", "b", "c"]); // string | undefined
// 型パラメータ T が自動推論される

// 制約なし — length プロパティの保証がない
function getLength<T>(arg: T): number {
  // return arg.length; // エラー！T に length があるとは限らない
  return 0;
}

// extends で制約を追加 — length を持つ型のみ受け入れる
function getLength<T extends { length: number }>(arg: T): number {
  return arg.length; // OK! length の存在が保証される
}

getLength("hello");     // OK: string は length を持つ
getLength([1, 2, 3]);   // OK: Array は length を持つ
// getLength(42);        // エラー！number は length を持たない

// デフォルト型パラメータ
interface ApiResponse<T = unknown> {
  data: T;
  status: number;
  message: string;
}

// T を指定しない場合は unknown がデフォルト
const response: ApiResponse = { data: "anything", status: 200, message: "ok" };

// T を明示的に指定
const typedResponse: ApiResponse<string[]> = {
  data: ["item1", "item2"],
  status: 200,
  message: "ok",
};

// 基本構文: T extends U ? X : Y
type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<string>;  // "yes"
type B = IsString<number>;  // "no"
type C = IsString<"hello">; // "yes" (リテラル型も string を拡張する)

type ToArray<T> = T extends any ? T[] : never;

// ユニオン型に適用すると分配される
type Result = ToArray<string | number>;
// = (string extends any ? string[] : never) | (number extends any ? number[] : never)
// = string[] | number[]

// 注意: T[] とするだけでは (string | number)[] になる
type WithoutDistribution = (string | number)[];  // (string | number)[]
type WithDistribution = ToArray<string | number>; // string[] | number[]

// 全プロパティをオプショナルにする（Partial の実装）
type MyPartial<T> = {
  [K in keyof T]?: T[K];
};

// 全プロパティを読み取り専用にする（Readonly の実装）
type MyReadonly<T> = {
  readonly [K in keyof T]: T[K];
};

// 修飾子の除去: -? でオプショナルを外す
type Required<T> = {
  [K in keyof T]-?: T[K];
};

// -readonly で読み取り専用を外す
type Mutable<T> = {
  -readonly [K in keyof T]: T[K];
};

// イベント名の型を自動生成
type EventName = `on${Capitalize<"click" | "focus" | "blur">}`;
// = "onClick" | "onFocus" | "onBlur"

// CSSプロパティのパターン
type CSSUnit = "px" | "em" | "rem" | "%";
type CSSValue = `${number}${CSSUnit}`;
// "100px", "1.5em", "2rem", "50%" などが有効

// HTTPエンドポイントの型安全なルーティング
type ApiRoute = `/api/${"users" | "posts" | "comments"}/${number}`;
// "/api/users/1", "/api/posts/42" などが有効

interface User {
  id: number;
  name: string;
  email: string;
  createdAt: Date;
}

// 更新API — 全フィールドがオプショナル
type UpdateUser = Partial<User>;
// { id?: number; name?: string; email?: string; createdAt?: Date; }

// 公開プロフィール — emailとcreatedAtを除外
type PublicProfile = Pick<User, "id" | "name">;
// { id: number; name: string; }

// ID以外の作成時データ
type CreateUser = Omit<User, "id" | "createdAt">;
// { name: string; email: string; }

// as const なし — 型が拡大される
const colors = ["red", "green", "blue"];
// 型: string[]

// as const あり — リテラル型が保持される
const colors = ["red", "green", "blue"] as const;
// 型: readonly ["red", "green", "blue"]

// ユニオン型の自動生成
type Color = (typeof colors)[number]; // "red" | "green" | "blue"

// 設定オブジェクトに最適
const config = {
  port: 3000,
  host: "localhost",
  debug: true,
} as const;
// 型: { readonly port: 3000; readonly host: "localhost"; readonly debug: true; }

type ColorMap = Record<string, string | number[]>;

// satisfies: 型チェックしつつ、各プロパティの推論型を保持
const palette = {
  red: "#ff0000",
  green: [0, 255, 0],
} satisfies ColorMap;

palette.red.toUpperCase();      // ✅ OK: string型として推論維持
palette.green.map(x => x * 2); // ✅ OK: number[]型として推論維持

// as を使った場合は各プロパティが string | number[] になってしまう
const paletteWithAs = {
  red: "#ff0000",
  green: [0, 255, 0],
} as ColorMap;

// paletteWithAs.red.toUpperCase(); // ❌ エラー: string | number[] にはtoUpperCaseがない

// 関数の戻り値型を抽出（ReturnType の実装）
type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

type A = MyReturnType<() => string>;        // string
type B = MyReturnType<(x: number) => void>; // void

// 配列の要素型を抽出
type ElementType<T> = T extends (infer E)[] ? E : never;

type C = ElementType<string[]>;  // string
type D = ElementType<number[]>;  // number

// Promiseのアンラップ（Awaited の簡易実装）
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

type E = UnwrapPromise<Promise<string>>; // string
type F = UnwrapPromise<number>;           // number

// 型安全なルーティング定義
type Route = { path: string; method: "GET" | "POST" | "PUT" | "DELETE" };

const routes = [
  { path: "/users", method: "GET" },
  { path: "/users", method: "POST" },
  { path: "/users/:id", method: "PUT" },
] as const satisfies readonly Route[];

// routes[0].method の型は "GET"（リテラル型） ← as const の効果
// かつ Route 型に適合していることが保証される ← satisfies の効果