function calculateTotal(price, quantity) {
  return price * quantity;
}

// 意図しない使い方 — エラーにならない
console.log(calculateTotal("100", 3)); // "100100100"（文字列の繰り返し）
console.log(calculateTotal(100));       // NaN（quantityがundefined）

function calculateTotal(price: number, quantity: number): number {
  return price * quantity;
}

calculateTotal("100", 3);  // コンパイルエラー！ string は number に割り当てられない
calculateTotal(100);        // コンパイルエラー！ 引数が足りない
calculateTotal(100, 3);     // OK: 300

TypeScript (.ts)
    ↓ tsc（TypeScriptコンパイラ）
JavaScript (.js)
    ↓
ブラウザ / Node.js で実行

# バージョン確認
node --version   # v20.x.x 以上を推奨
npm --version    # 10.x.x 以上

# TypeScriptのインストール
npm install -g typescript
tsc --version    # Version 5.x.x

// hello.ts
const message: string = "Hello, TypeScript!";
console.log(message);

# コンパイルと実行
tsc hello.ts      # hello.js が生成される
node hello.js     # Hello, TypeScript!

tsc --init  # tsconfig.json を自動生成

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "strict": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "esModuleInterop": true
  },
  "include": ["src/**/*"]
}

// JavaScript → TypeScript の変化

// 1. 変数に型がつく
let count: number = 0;
let name: string = "太郎";
let isActive: boolean = true;

// 2. 関数の引数と戻り値に型がつく
function greet(name: string): string {
  return `こんにちは、${name}さん`;
}

// 3. オブジェクトの形が定義できる
interface User {
  id: number;
  name: string;
  email: string;
}

const user: User = {
  id: 1,
  name: "太郎",
  email: "taro@example.com",
};

// exercise.ts
// 課題:
// 1. 以下の関数に型注釈を追加してください
// 2. tsc exercise.ts でコンパイルし、エラーがないことを確認
// 3. 意図的に型エラーを起こし、エラーメッセージを確認

function add(a, b) {
  return a + b;
}

function formatUser(name, age) {
  return `${name} (${age}歳)`;
}

console.log(add(10, 20));
console.log(formatUser("太郎", 25));

// 数値
let price: number = 1980;
let pi: number = 3.14159;
let hex: number = 0xff;

// 文字列
let greeting: string = "こんにちは";
let template: string = `価格は${price}円です`;

// 真偽値
let isPublished: boolean = true;

// null と undefined
let nothing: null = null;
let notDefined: undefined = undefined;

let count = 0;          // number と推論
let name = "太郎";      // string と推論
let active = true;      // boolean と推論

count = "hello";  // エラー！ string を number に代入できない

// 配列の型定義（2つの書き方）
let numbers: number[] = [1, 2, 3];
let names: Array<string> = ["太郎", "花子"];

// 型安全な配列操作
numbers.push(4);       // OK
numbers.push("five");  // エラー！ string は number[] に追加できない

// 読み取り専用配列
const colors: readonly string[] = ["red", "green", "blue"];
colors.push("yellow");  // エラー！ readonly配列は変更不可

// [名前, 年齢, アクティブ]
let user: [string, number, boolean] = ["太郎", 25, true];

user[0].toUpperCase();  // OK — stringのメソッドが使える
user[1].toFixed(2);     // OK — numberのメソッドが使える
user[3];                // エラー！ インデックス3は存在しない

// インラインのオブジェクト型
let product: { name: string; price: number; inStock: boolean } = {
  name: "TypeScript入門書",
  price: 2980,
  inStock: true,
};

// オプショナルプロパティ（?をつける）
let config: { host: string; port?: number } = {
  host: "localhost",
  // port は省略可能
};

// string または number
let id: string | number;
id = "abc-123";  // OK
id = 42;         // OK
id = true;       // エラー！ boolean は不可

// 関数の引数で活用
function formatId(id: string | number): string {
  if (typeof id === "string") {
    return id.toUpperCase();  // string のメソッドが使える
  }
  return id.toFixed(0);      // number のメソッドが使える
}

// "left" | "center" | "right" のいずれかのみ
let align: "left" | "center" | "right" = "center";
align = "top";  // エラー！ "top" は許可されていない

// HTTP メソッド
type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";

function request(url: string, method: HttpMethod): void {
  console.log(`${method} ${url}`);
}

request("/api/users", "GET");     // OK
request("/api/users", "PATCH");   // エラー！

// any — 型チェックを完全に無効化（使用は最小限に）
let dangerous: any = "hello";
dangerous.nonExistentMethod();  // エラーにならない！危険！

// unknown — 安全な any。使う前に型チェックが必要
let safe: unknown = "hello";
safe.toUpperCase();  // エラー！ unknown のまま使えない

if (typeof safe === "string") {
  safe.toUpperCase();  // OK — string に絞り込んだ後
}

// never — 決して起こらない型
function throwError(message: string): never {
  throw new Error(message);
  // この関数は正常にreturnしない
}

type UserId = string | number;
type Status = "active" | "inactive" | "suspended";

type Product = {
  id: UserId;
  name: string;
  price: number;
  status: Status;
};

const item: Product = {
  id: "prod-001",
  name: "TypeScript入門書",
  price: 2980,
  status: "active",
};

// TypeScript は getElementById の戻り値を HTMLElement | null と推論
const input = document.getElementById("email") as HTMLInputElement;
input.value = "test@example.com";  // HTMLInputElement のプロパティにアクセス可能

// 非nullアサーション（! 演算子）
const element = document.getElementById("app")!;
// null ではないと断言（nullの場合は実行時エラー）

// 課題: 以下のJavaScriptコードに適切な型注釈を追加してください

function createUser(name, age, email) {
  return { name, age, email, createdAt: new Date() };
}

function getUserAge(user) {
  return user.age;
}

const users = [
  createUser("太郎", 25, "taro@example.com"),
  createUser("花子", 30, "hanako@example.com"),
];

const ages = users.map(getUserAge);
const totalAge = ages.reduce((sum, age) => sum + age, 0);
console.log(`平均年齢: ${totalAge / users.length}`);

interface User {
  id: number;
  name: string;
  email: string;
  age?: number;           // オプショナル（省略可能）
  readonly createdAt: Date; // 読み取り専用
}

const user: User = {
  id: 1,
  name: "太郎",
  email: "taro@example.com",
  createdAt: new Date(),
};

user.name = "花子";       // OK — 変更可能
user.createdAt = new Date(); // エラー！ readonly は変更不可
user.phone;               // エラー！ phone は User に存在しない

interface BaseEntity {
  id: number;
  createdAt: Date;
  updatedAt: Date;
}

interface User extends BaseEntity {
  name: string;
  email: string;
}

interface AdminUser extends User {
  role: "admin" | "superadmin";
  permissions: string[];
}

const admin: AdminUser = {
  id: 1,
  createdAt: new Date(),
  updatedAt: new Date(),
  name: "管理者",
  email: "admin@example.com",
  role: "admin",
  permissions: ["users.read", "users.write"],
};

// Union型（interfaceでは不可能）
type Status = "draft" | "published" | "archived";
type Id = string | number;

// 交差型（&）— 複数の型を合成
type Timestamped = {
  createdAt: Date;
  updatedAt: Date;
};

type User = {
  id: number;
  name: string;
};

type UserWithTimestamp = User & Timestamped;
// { id: number; name: string; createdAt: Date; updatedAt: Date }

// 宣言のマージ（interfaceのみ）
interface Config {
  host: string;
}
interface Config {
  port: number;
}
// Config = { host: string; port: number } に自動マージ

// type では不可能
type Config2 = { host: string };
type Config2 = { port: number }; // エラー！ 重複した識別子

// 文字列キー → 数値値のマップ
interface ScoreMap {
  [subject: string]: number;
}

const scores: ScoreMap = {
  math: 90,
  english: 85,
  science: 92,
};

// 既知のキーとインデックスシグネチャの組み合わせ
interface ApiResponse {
  status: number;
  message: string;
  [key: string]: unknown;  // 追加プロパティを許容
}

// type で関数型を定義
type Formatter = (value: number) => string;

const formatCurrency: Formatter = (value) => {
  return `¥${value.toLocaleString()}`;
};

console.log(formatCurrency(19800));  // "¥19,800"

// interface でも定義可能（コールシグネチャ）
interface Calculator {
  (a: number, b: number): number;
}

const add: Calculator = (a, b) => a + b;
const multiply: Calculator = (a, b) => a * b;

interface Address {
  postalCode: string;
  prefecture: string;
  city: string;
  line: string;
}

interface Company {
  name: string;
  address: Address;
  employees: number;
}

interface UserProfile {
  id: number;
  name: string;
  company: Company;
  tags: string[];
  settings: {
    theme: "light" | "dark";
    language: "ja" | "en";
    notifications: boolean;
  };
}

interface SuccessResponse {
  status: "success";
  data: { id: number; name: string };
}

interface ErrorResponse {
  status: "error";
  message: string;
  code: number;
}

type ApiResponse = SuccessResponse | ErrorResponse;

function handleResponse(response: ApiResponse): void {
  switch (response.status) {
    case "success":
      // TypeScriptは response が SuccessResponse だと推論
      console.log(response.data.name);
      break;
    case "error":
      // TypeScriptは response が ErrorResponse だと推論
      console.log(`Error ${response.code}: ${response.message}`);
      break;
  }
}

// 課題: 以下のECサイトのデータ構造を型定義してください
// 1. Product interface（id, name, price, category, inStock）
// 2. CartItem（Product + quantity）
// 3. Order（id, items: CartItem[], total, status）
//    status は "pending" | "paid" | "shipped" | "delivered"
// 4. calculateTotal 関数の型を定義して実装

// ヒント:
// interface CartItem extends Product { ... }
// または type CartItem = Product & { quantity: number }

function getFirstNumber(arr: number[]): number | undefined {
  return arr[0];
}

function getFirstString(arr: string[]): string | undefined {
  return arr[0];
}

// ロジックは全く同じなのに、型ごとに関数を書くのは無駄

function getFirst<T>(arr: T[]): T | undefined {
  return arr[0];
}

// T は呼び出し時に具体的な型に置き換わる
const num = getFirst([1, 2, 3]);           // T = number → number | undefined
const str = getFirst(["a", "b", "c"]);     // T = string → string | undefined
const user = getFirst([{ name: "太郎" }]); // T = { name: string } → { name: string } | undefined

interface ApiResponse<T> {
  data: T;
  status: number;
  message: string;
}

// 型パラメータ T に具体的な型を渡す
type UserResponse = ApiResponse<{ id: number; name: string }>;
type ProductListResponse = ApiResponse<{ id: number; name: string; price: number }[]>;

function fetchApi<T>(url: string): Promise<ApiResponse<T>> {
  return fetch(url).then((res) => res.json());
}

// 呼び出し時に期待する型を指定
const users = await fetchApi<{ id: number; name: string }[]>("/api/users");
// users.data は { id: number; name: string }[] として型チェックされる

function mapObject<K extends string, V, R>(
  obj: Record<K, V>,
  fn: (value: V) => R
): Record<K, R> {
  const result = {} as Record<K, R>;
  for (const key in obj) {
    result[key] = fn(obj[key]);
  }
  return result;
}

const prices = { apple: 100, banana: 200, cherry: 300 };
const formatted = mapObject(prices, (v) => `¥${v}`);
// formatted: { apple: string; banana: string; cherry: string }

// T は { length: number } を持つ型でなければならない
function logLength<T extends { length: number }>(value: T): void {
  console.log(`Length: ${value.length}`);
}

logLength("hello");     // OK — string は length を持つ
logLength([1, 2, 3]);   // OK — 配列は length を持つ
logLength(42);          // エラー！ number には length がない

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { name: "太郎", age: 25, email: "taro@example.com" };

getProperty(user, "name");   // 戻り値: string
getProperty(user, "age");    // 戻り値: number
getProperty(user, "phone");  // エラー！ "phone" は keyof User にない

class Stack<T> {
  private items: T[] = [];

  push(item: T): void {
    this.items.push(item);
  }

  pop(): T | undefined {
    return this.items.pop();
  }

  peek(): T | undefined {
    return this.items[this.items.length - 1];
  }

  get size(): number {
    return this.items.length;
  }
}

const numberStack = new Stack<number>();
numberStack.push(1);
numberStack.push(2);
numberStack.push("three");  // エラー！ string は number に割り当てられない

const stringStack = new Stack<string>();
stringStack.push("hello");

// ページネーション付きレスポンス
interface PaginatedResponse<T> {
  items: T[];
  total: number;
  page: number;
  perPage: number;
  hasNext: boolean;
}

interface User {
  id: number;
  name: string;
}

interface Product {
  id: number;
  name: string;
  price: number;
}

// 同じ構造で異なるデータ型を格納
type UserPage = PaginatedResponse<User>;
type ProductPage = PaginatedResponse<Product>;

interface EventPayload<T = Record<string, unknown>> {
  type: string;
  timestamp: Date;
  data: T;
}

// T を省略するとデフォルトが適用
const event1: EventPayload = {
  type: "pageview",
  timestamp: new Date(),
  data: { url: "/home" },
};

// T を明示的に指定
const event2: EventPayload<{ userId: number; action: string }> = {
  type: "click",
  timestamp: new Date(),
  data: { userId: 1, action: "purchase" },
};

// 1. 配列操作
function filterByType<T>(arr: unknown[], guard: (x: unknown) => x is T): T[] {
  return arr.filter(guard);
}

// 2. Promise のラップ
async function withRetry<T>(fn: () => Promise<T>, retries: number): Promise<T> {
  for (let i = 0; i < retries; i++) {
    try {
      return await fn();
    } catch (e) {
      if (i === retries - 1) throw e;
    }
  }
  throw new Error("Unreachable");
}

// 3. イベントエミッター
interface EventMap {
  login: { userId: number };
  logout: { userId: number };
  error: { message: string; code: number };
}

function emit<K extends keyof EventMap>(event: K, payload: EventMap[K]): void {
  console.log(`Event: ${event}`, payload);
}

emit("login", { userId: 1 });           // OK
emit("error", { message: "fail", code: 500 }); // OK
emit("login", { message: "wrong" });     // エラー！ 型が合わない

// 課題:
// 1. ジェネリックな groupBy 関数を実装
//    groupBy<T>(arr: T[], key: keyof T): Record<string, T[]>
//    例: groupBy(users, "city") → { "東京": [...], "大阪": [...] }

// 2. ジェネリックな Result 型を定義
//    type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E }
//    safeDivide(a: number, b: number): Result<number, string> を実装

// 3. ジェネリックな Cache クラスを実装
//    get(key: string): T | undefined
//    set(key: string, value: T, ttlMs: number): void
//    期限切れのエントリは get 時に自動削除

interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

// 全プロパティが省略可能になる
type UserUpdate = Partial<User>;
// { id?: number; name?: string; email?: string; age?: number }

function updateUser(id: number, updates: Partial<User>): void {
  // 名前だけ更新、メールだけ更新 — どちらもOK
  console.log(`Updating user ${id}:`, updates);
}

updateUser(1, { name: "花子" });           // OK
updateUser(1, { email: "new@example.com" }); // OK
updateUser(1, {});                          // OK（空でもエラーにならない）

interface Config {
  host?: string;
  port?: number;
  debug?: boolean;
}

type RequiredConfig = Required<Config>;
// { host: string; port: number; debug: boolean }

// デフォルト値で埋める関数
function createConfig(partial: Config): RequiredConfig {
  return {
    host: partial.host ?? "localhost",
    port: partial.port ?? 3000,
    debug: partial.debug ?? false,
  };
}

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

// 公開可能な情報だけ抽出
type PublicUser = Pick<User, "id" | "name" | "email">;
// { id: number; name: string; email: string }

// APIレスポンスでパスワードを含めない
function getPublicProfile(user: User): PublicUser {
  return { id: user.id, name: user.name, email: user.email };
}

// 作成時にはIDとタイムスタンプは不要
type CreateUserInput = Omit<User, "id" | "createdAt">;
// { name: string; email: string; password: string }

function createUser(input: CreateUserInput): User {
  return {
    ...input,
    id: Math.random(),
    createdAt: new Date(),
  };
}

// ステータスごとのラベル定義
type Status = "draft" | "published" | "archived";

const statusLabels: Record<Status, string> = {
  draft: "下書き",
  published: "公開中",
  archived: "アーカイブ済み",
};

// すべてのステータスに対応が必須 — 1つでも漏れるとエラー
const statusColors: Record<Status, string> = {
  draft: "#gray",
  published: "#green",
  // archived が抜けている → コンパイルエラー！
};

interface State {
  count: number;
  items: string[];
}

const state: Readonly<State> = {
  count: 0,
  items: ["a", "b"],
};

state.count = 1;       // エラー！ readonly プロパティ
state.items.push("c"); // 注意: これはエラーにならない（浅いReadonly）

// as const なし
const routes = {
  home: "/",
  about: "/about",
  users: "/users",
};
// 型: { home: string; about: string; users: string }

// as const あり
const routes2 = {
  home: "/",
  about: "/about",
  users: "/users",
} as const;
// 型: { readonly home: "/"; readonly about: "/about"; readonly users: "/users" }

// 値からUnion型を抽出
type Route = (typeof routes2)[keyof typeof routes2];
// "/" | "/about" | "/users"

type AllStatus = "draft" | "published" | "archived" | "deleted";

// 特定の型を除外
type ActiveStatus = Exclude<AllStatus, "deleted">;
// "draft" | "published" | "archived"

// 特定の型だけ抽出
type VisibleStatus = Extract<AllStatus, "draft" | "published">;
// "draft" | "published"

type MaybeString = string | null | undefined;
type DefiniteString = NonNullable<MaybeString>;
// string

function createUser(name: string, age: number) {
  return { id: Date.now(), name, age };
}

type UserReturnType = ReturnType<typeof createUser>;
// { id: number; name: string; age: number }

type UserParams = Parameters<typeof createUser>;
// [name: string, age: number]

interface Product {
  id: number;
  name: string;
  description: string;
  price: number;
  category: string;
  imageUrl: string;
  createdAt: Date;
  updatedAt: Date;
}

// 作成用（IDとタイムスタンプを除外）
type CreateProduct = Omit<Product, "id" | "createdAt" | "updatedAt">;

// 更新用（全フィールドがオプショナル、ただしIDは不要）
type UpdateProduct = Partial<Omit<Product, "id" | "createdAt" | "updatedAt">>;

// 一覧表示用（軽量）
type ProductSummary = Pick<Product, "id" | "name" | "price" | "imageUrl">;

// 検索フィルター
type ProductFilter = Partial<Pick<Product, "category" | "price">>;

// 課題:
// 1. 以下の BlogPost 型から、用途別の型を派生させてください
interface BlogPost {
  id: number;
  title: string;
  content: string;
  author: string;
  tags: string[];
  status: "draft" | "published";
  publishedAt: Date | null;
  createdAt: Date;
  updatedAt: Date;
}

// - CreateBlogPost: 作成用（id, createdAt, updatedAt を除外）
// - UpdateBlogPost: 更新用（id を除外、全てオプショナル）
// - BlogPostCard: 一覧表示用（id, title, author, status, publishedAt のみ）

// 2. Record を使って、status ごとの BlogPost[] を格納するマップ型を定義

// 3. ReturnType を使って、以下の関数の戻り値型を抽出
function fetchPosts(page: number, limit: number) {
  return { posts: [] as BlogPost[], total: 0, hasNext: false };
}

// 関数宣言
function add(a: number, b: number): number {
  return a + b;
}

// アロー関数
const multiply = (a: number, b: number): number => a * b;

// 戻り値の型推論（明示しなくても推論される）
const divide = (a: number, b: number) => a / b;
// 戻り値は number と自動推論

// オプショナル引数（?）
function greet(name: string, greeting?: string): string {
  return `${greeting ?? "こんにちは"}、${name}さん`;
}
greet("太郎");              // "こんにちは、太郎さん"
greet("太郎", "おはよう");  // "おはよう、太郎さん"

// デフォルト値（型注釈は不要 — 値から推論される）
function createUser(name: string, role = "user") {
  return { name, role };
}
// role は string 型と推論される

function sum(...numbers: number[]): number {
  return numbers.reduce((total, n) => total + n, 0);
}

sum(1, 2, 3);       // 6
sum(10, 20, 30, 40); // 100

// コールバックの型を明示
function fetchData(url: string, onSuccess: (data: unknown) => void, onError: (error: Error) => void): void {
  fetch(url)
    .then((res) => res.json())
    .then(onSuccess)
    .catch(onError);
}

// 型エイリアスでコールバック型を定義
type EventHandler<T> = (event: T) => void;

interface ClickEvent {
  x: number;
  y: number;
  target: string;
}

function onClick(handler: EventHandler<ClickEvent>): void {
  // handler の引数は ClickEvent として型チェックされる
  handler({ x: 100, y: 200, target: "button" });
}

onClick((event) => {
  console.log(`Clicked at (${event.x}, ${event.y})`);
});

// オーバーロードシグネチャ
function createElement(tag: "a"): HTMLAnchorElement;
function createElement(tag: "canvas"): HTMLCanvasElement;
function createElement(tag: "div"): HTMLDivElement;
function createElement(tag: string): HTMLElement;

// 実装（引数を最も広い型で受ける）
function createElement(tag: string): HTMLElement {
  return document.createElement(tag);
}

const anchor = createElement("a");     // HTMLAnchorElement
const canvas = createElement("canvas"); // HTMLCanvasElement
const div = createElement("div");       // HTMLDivElement
const span = createElement("span");     // HTMLElement

function formatValue(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();   // string のメソッドが使える
  }
  return value.toFixed(2);       // number のメソッドが使える
}

class ApiError extends Error {
  constructor(
    message: string,
    public statusCode: number
  ) {
    super(message);
  }
}

function handleError(error: Error | ApiError): void {
  if (error instanceof ApiError) {
    console.log(`API Error ${error.statusCode}: ${error.message}`);
  } else {
    console.log(`Error: ${error.message}`);
  }
}

interface Fish {
  swim: () => void;
}

interface Bird {
  fly: () => void;
}

// カスタム型ガード
function isFish(animal: Fish | Bird): animal is Fish {
  return "swim" in animal;
}

function move(animal: Fish | Bird): void {
  if (isFish(animal)) {
    animal.swim();  // Fish として認識
  } else {
    animal.fly();   // Bird として認識
  }
}

interface Admin {
  role: "admin";
  permissions: string[];
}

interface Guest {
  role: "guest";
  expiresAt: Date;
}

function getAccess(user: Admin | Guest): string[] {
  if ("permissions" in user) {
    return user.permissions;  // Admin
  }
  return ["read"];            // Guest
}

// async関数の戻り値は自動的に Promise<T> になる
async function fetchUser(id: number): Promise<{ name: string; email: string }> {
  const response = await fetch(`/api/users/${id}`);
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}`);
  }
  return response.json();
}

// Promise の型パラメータ
type AsyncFn<T> = () => Promise<T>;

async function withTimeout<T>(fn: AsyncFn<T>, ms: number): Promise<T> {
  const result = await Promise.race([
    fn(),
    new Promise<never>((_, reject) =>
      setTimeout(() => reject(new Error("Timeout")), ms)
    ),
  ]);
  return result;
}

interface Button {
  label: string;
  onClick(this: Button): void;
}

const button: Button = {
  label: "送信",
  onClick() {
    console.log(`${this.label} がクリックされました`);
  },
};

button.onClick();  // OK — this は Button

const handler = button.onClick;
handler();  // エラー！ this の型が void で Button と互換性がない

// 課題: 型安全なイベントエミッターを実装
// 1. EventMap を定義（イベント名 → ペイロードの型）
// 2. on(event, handler) — イベントリスナーを登録
// 3. emit(event, payload) — イベントを発火
// 4. off(event, handler) — リスナーを解除

// ヒント:
interface EventMap {
  userLogin: { userId: number; timestamp: Date };
  pageView: { url: string; referrer: string | null };
  error: { message: string; stack?: string };
}

// emitter.on("userLogin", (payload) => { ... })
// payload は自動的に { userId: number; timestamp: Date } と推論されるべき

// user.ts — 名前付きエクスポート
export interface User {
  id: number;
  name: string;
  email: string;
}

export function createUser(name: string, email: string): User {
  return { id: Date.now(), name, email };
}

export const MAX_USERS = 1000;

// app.ts — インポート
import { User, createUser, MAX_USERS } from "./user";

const user: User = createUser("太郎", "taro@example.com");

// logger.ts
export default class Logger {
  log(message: string): void {
    console.log(`[${new Date().toISOString()}] ${message}`);
  }
}

// app.ts — デフォルトインポートは任意の名前で受け取れる
import Logger from "./logger";
const logger = new Logger();

// models/user.ts
export interface User { ... }

// models/product.ts
export interface Product { ... }

// models/index.ts — バレルファイル
export { User } from "./user";
export { Product } from "./product";

// 利用側
import { User, Product } from "./models";  // index.ts から一括インポート

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

# lodashの型定義をインストール
npm install lodash
npm install -D @types/lodash

# 型定義が不要なライブラリ（TypeScript製）
npm install zod         # 型定義が同梱されている
npm install axios       # 型定義が同梱されている

// @types/lodash のおかげで型チェックが効く
import _ from "lodash";

const sorted = _.sortBy([{ name: "花子", age: 30 }, { name: "太郎", age: 25 }], "age");
// sorted は { name: string; age: number }[] と推論

src/
├── index.ts
├── types.ts        ← 共通の型定義
├── utils.ts        ← ユーティリティ関数
├── api.ts          ← API呼び出し
└── config.ts       ← 設定値

src/
├── types/           ← 型定義
│   ├── user.ts
│   ├── product.ts
│   └── index.ts
├── services/        ← ビジネスロジック
│   ├── userService.ts
│   └── productService.ts
├── repositories/    ← データアクセス
│   ├── userRepo.ts
│   └── productRepo.ts
├── utils/           ← 汎用ユーティリティ
│   ├── validation.ts
│   └── formatting.ts
└── index.ts

src/
├── features/
│   ├── auth/
│   │   ├── types.ts
│   │   ├── authService.ts
│   │   └── authMiddleware.ts
│   ├── users/
│   │   ├── types.ts
│   │   ├── userService.ts
│   │   └── userRouter.ts
│   └── products/
│       ├── types.ts
│       ├── productService.ts
│       └── productRouter.ts
├── shared/
│   ├── types.ts
│   └── utils.ts
└── index.ts

// 非推奨（namespace）
namespace MyApp {
  export interface User { id: number }
}

// 推奨（ESモジュール）
// types/user.ts
export interface User { id: number }

// env.d.ts — 環境変数に型をつける
declare namespace NodeJS {
  interface ProcessEnv {
    NODE_ENV: "development" | "production" | "test";
    DATABASE_URL: string;
    API_KEY: string;
    PORT?: string;
  }
}

// 使用時（型チェックと補完が効く）
const port = parseInt(process.env.PORT ?? "3000");
const dbUrl = process.env.DATABASE_URL;  // string（必須なので undefined にならない）

import { z } from "zod";

// スキーマ定義（バリデーションルール + 型定義を兼ねる）
const UserSchema = z.object({
  name: z.string().min(1).max(100),
  email: z.string().email(),
  age: z.number().int().min(0).max(150),
});

// スキーマから TypeScript の型を自動生成
type User = z.infer<typeof UserSchema>;
// { name: string; email: string; age: number }

// バリデーション
const result = UserSchema.safeParse({
  name: "太郎",
  email: "taro@example.com",
  age: 25,
});

if (result.success) {
  const user: User = result.data;  // 型安全
} else {
  console.error(result.error.issues);
}

# 課題:
# 1. 新しいプロジェクトを作成
mkdir ts-practice && cd ts-practice
npm init -y
npm install typescript @types/node -D
npx tsc --init

# 2. src/ ディレクトリにレイヤードアーキテクチャで以下を実装
#    - types/todo.ts: Todo interface
#    - services/todoService.ts: CRUD 関数（メモリ内配列で管理）
#    - index.ts: サービスを使ってTodoを操作

# 3. "strict": true でコンパイルエラーが0であることを確認
# 4. zod でTodo作成時のバリデーションを追加

try {
  const data = JSON.parse(invalidJson);
} catch (error) {
  // error は unknown 型 — 何のプロパティにもアクセスできない
  console.log(error.message);  // エラー！

  // 型を絞り込む必要がある
  if (error instanceof Error) {
    console.log(error.message);  // OK
  }
}

type Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E };

function divide(a: number, b: number): Result<number, string> {
  if (b === 0) {
    return { ok: false, error: "ゼロで割ることはできません" };
  }
  return { ok: true, value: a / b };
}

const result = divide(10, 0);
if (result.ok) {
  console.log(result.value);  // number — 型安全
} else {
  console.log(result.error);  // string — 型安全
}

// 非同期版
async function fetchUser(id: number): Promise<Result<User, ApiError>> {
  try {
    const res = await fetch(`/api/users/${id}`);
    if (!res.ok) {
      return { ok: false, error: { status: res.status, message: res.statusText } };
    }
    const data = await res.json();
    return { ok: true, value: data };
  } catch {
    return { ok: false, error: { status: 0, message: "Network error" } };
  }
}

interface ApiError {
  status: number;
  message: string;
}

class NotFoundError extends Error {
  constructor(
    public resource: string,
    public id: string | number
  ) {
    super(`${resource} with id ${id} not found`);
    this.name = "NotFoundError";
  }
}

class ValidationError extends Error {
  constructor(
    public field: string,
    public reason: string
  ) {
    super(`Validation failed for ${field}: ${reason}`);
    this.name = "ValidationError";
  }
}

class UnauthorizedError extends Error {
  constructor() {
    super("Authentication required");
    this.name = "UnauthorizedError";
  }
}

type AppError = NotFoundError | ValidationError | UnauthorizedError;

function handleError(error: AppError): { status: number; message: string } {
  if (error instanceof NotFoundError) {
    return { status: 404, message: error.message };
  }
  if (error instanceof ValidationError) {
    return { status: 400, message: `${error.field}: ${error.reason}` };
  }
  if (error instanceof UnauthorizedError) {
    return { status: 401, message: error.message };
  }
  const _exhaustive: never = error;  // 全ケースを網羅したことを保証
  return _exhaustive;
}

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rectangle":
      return shape.width * shape.height;
    case "triangle":
      return (shape.base * shape.height) / 2;
    default: {
      const _exhaustive: never = shape;
      return _exhaustive;
    }
  }
}

// UserId と ProductId を型レベルで区別
type UserId = number & { readonly __brand: "UserId" };
type ProductId = number & { readonly __brand: "ProductId" };

function createUserId(id: number): UserId {
  return id as UserId;
}

function createProductId(id: number): ProductId {
  return id as ProductId;
}

function getUser(id: UserId): void {
  console.log(`Fetching user ${id}`);
}

const userId = createUserId(1);
const productId = createProductId(1);

getUser(userId);     // OK
getUser(productId);  // エラー！ ProductId は UserId に代入できない
getUser(42);         // エラー！ number は UserId に代入できない

interface EventMap {
  click: { x: number; y: number };
  keypress: { key: string; code: string };
  submit: { formData: Record<string, string> };
}

class TypedEmitter<T extends Record<string, unknown>> {
  private handlers = new Map<keyof T, Set<(payload: any) => void>>();

  on<K extends keyof T>(event: K, handler: (payload: T[K]) => void): void {
    if (!this.handlers.has(event)) {
      this.handlers.set(event, new Set());
    }
    this.handlers.get(event)!.add(handler);
  }

  emit<K extends keyof T>(event: K, payload: T[K]): void {
    this.handlers.get(event)?.forEach((handler) => handler(payload));
  }
}

const emitter = new TypedEmitter<EventMap>();

emitter.on("click", (payload) => {
  console.log(payload.x, payload.y);  // 型安全: x, y は number
});

emitter.emit("click", { x: 100, y: 200 });        // OK
emitter.emit("click", { key: "a", code: "KeyA" }); // エラー！ 型が合わない

class QueryBuilder<T extends Record<string, unknown>> {
  private conditions: string[] = [];
  private ordering: string | null = null;
  private limitValue: number | null = null;

  where(condition: string): this {
    this.conditions.push(condition);
    return this;
  }

  orderBy(field: keyof T & string, direction: "asc" | "desc" = "asc"): this {
    this.ordering = `${field} ${direction}`;
    return this;
  }

  limit(n: number): this {
    this.limitValue = n;
    return this;
  }

  build(): string {
    let query = "SELECT * FROM table";
    if (this.conditions.length) {
      query += ` WHERE ${this.conditions.join(" AND ")}`;
    }
    if (this.ordering) query += ` ORDER BY ${this.ordering}`;
    if (this.limitValue) query += ` LIMIT ${this.limitValue}`;
    return query;
  }
}

interface UserRow {
  id: number;
  name: string;
  createdAt: Date;
}

const query = new QueryBuilder<UserRow>()
  .where("name LIKE '%太郎%'")
  .orderBy("createdAt", "desc")
  .limit(10)
  .build();