let size = "small";
// let size: string

const size = "small";
// const size: "small"

function setSize(size: "small" | "medium" | "large") {
  console.log(`Selected size: ${size}`);
}

setSize("small");       // OK
setSize("medium");      // OK
setSize("extra-large"); // コンパイルエラー：
// Argument of type '"extra-large"' is not assignable to parameter of type '"small" | "medium" | "large"'.

type WaferType = 
  | { kind: "kalėdaitis"; texture: "thin" }
  | { kind: "other"; texture: "thick" };

function describeWafer(wafer: WaferType) {
  if (wafer.kind === "kalėdaitis") {
    // waferはここでkind: "kalėdaitis"と判定され、textureは"thin"とわかる
    console.log("This is a traditional kalėdaitis.");
  } else {
    console.log("This is some other wafer.");
  }
}

const sizes = ["small", "medium", "large"];
// const sizes: string[]

sizes[0] = "tiny"; // OK

const sizes = ["small", "medium", "large"] as const;
// const sizes: readonly ["small", "medium", "large"]

sizes[0] = "tiny"; // コンパイルエラー：
// Cannot assign to '0' because it is a read-only property.

const lithuania = {
  country: "Lithuania",
  sweets: {
    kūčiukai: {
      ingredients: ["wheat flour", "poppy seeds", "water", "yeast"],
      texture: "hard",
      origin: "traditional"
    }
  },
  festival: "Kūčios"
} as const;
// const lithuania: {
//   readonly country: "Lithuania";
//   readonly sweets: {
//     readonly kūčiukai: {
//       readonly ingredients: readonly ["wheat flour", "poppy seeds", "water", "yeast"];
//       readonly texture: "hard";
//       readonly origin: "traditional";
//     };
//   };
//   readonly festival: "Kūčios";
// }

lithuania.sweets.kūčiukai.ingredients[0] = "rice flour";
// エラー：Type 'string' is not assignable to type '"wheat flour"'.

lithuania.sweets.kūčiukai.texture = "soft";
// エラー：Cannot assign to 'texture' because it is a read-only property.

type DrinkRecipe = {
  name: string;
  ingredients: string[];
};

// OK
const aguonuPienas = {
  name: "Aguonų pienas",
  ingredients: ["poppy seeds", "water"]
} satisfies DrinkRecipe;

// エラー
const errorDrink = {
  name: "Error",
  ingredients: "water", // 期待された文字列リストでないため、以下のエラーとなる：
  // Type 'string' is not assignable to type 'string[]'.
  // The expected type comes from property 'ingredients' which is declared here on type 'DrinkRecipe'
} satisfies DrinkRecipe;

type Flavor = "vanilla" | "chocolate";
type Dessert = {
  name: string;
  flavor: Flavor;
};

// この関数はflavorがリテラル型"vanilla"であることを要求する
function acceptVanillaOnly(d: { flavor: "vanilla" }) { /* ... */ }

// --- 型注釈の場合 ---
const dessertA: Dessert = {
  name: "Aguonų pienas",
  flavor: "vanilla"
};

// dessertA.flavorはFlavor型("vanilla" | "chocolate")であり、リテラル型"vanilla"ではない
acceptVanillaOnly(dessertA);
// エラー：dessertA.flavorは"vanilla"リテラルではないため、引数に合わない
// Argument of type 'Dessert' is not assignable to parameter of type '{ flavor: "vanilla"; }'.
//   Types of property 'flavor' are incompatible.
//      Type 'Flavor' is not assignable to type '"vanilla"'.
//        Type '"chocolate"' is not assignable to type '"vanilla"'.

// --- satisfiesの場合 ---
const dessertB = {
  name: "Aguonų pienas",
  flavor: "vanilla"
} satisfies Dessert;

// dessertB.flavorは"vanilla"リテラル型として推論され続ける
acceptVanillaOnly(dessertB); 
// OK：dessertB.flavorは厳密に"vanilla"であり、要求を満たす

export const colors = {
   Kūčiukai: "#ffffff",
   Aguonų: ["#000000", "#ffffff"], // 配列でもOK
   // satisfiesによる型安全性の確認
   Onion: "red",                   // satisfiesにより型を保証されているためエラー：
   // Type '"red"' is not assignable to type '`#${string}`'.
} as const satisfies {
  [key: string]: `#${string}` | (`#${string}`)[];
};

// as constによる値固定化の確認
colors.Aguonų = "#ff0000"; // as constによりradonlyであるためエラー：
// Cannot assign to 'Aguonų' because it is a read-only property.

// 配列が引数なければならない関数
function mapArray(arr: string[]) { return arr.map((v) => v) }

// as constによるwidening阻止の確認
mapArray(colors.Kūčiukai); // Kūčiukaiは配列でないため、当然エラー
mapArray(colors.Aguonų);   // as constによりwideningされないのでOK（型注釈などで実装した場合はエラーになる）

// ジェネリクスを使った配列作成関数
function createList<T>(item1: T, item2: T): T[] {
    return [item1, item2];
}

// 文字列リストを作成
const stringList = createList("Silkė", "Cepelinai");

// 数値リストを作成
const numberList = createList(2024, 1224);

console.log(stringList); // ["Silkė", "Cepelinai"]
console.log(numberList); // [2024, 1224]

// 複合リストを作成
const list = createList("A", 42); // 以下のエラーになる：
// Argument of type 'number' is not assignable to parameter of type 'string'.(2345)

function zip<T, U>(listA: T[], listB: U[]): Array<[T, U]> {
    const length = Math.min(listA.length, listB.length);
    const result: Array<[T, U]> = [];
    for (let i = 0; i < length; i++) {
        result.push([listA[i], listB[i]]);
    }
    return result;
}

// 文字列の料理名と数値の年号をペア化
const dishes = ["Silkė su svogūnais", "Cepelinai"];
const years = [2024, 1224];
const paired = zip(dishes, years);

console.log(paired);
// [ [ "Silkė su svogūnais", 2024 ], [ "Cepelinai", 1224 ] ]

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

function fetchItem<T>(url: string): Promise<ApiResponse<T>> {
    // 実装は省略（HTTPリクエストを送って結果を返す想定）
    return fetch(url)
        .then(res => res.json())
        .then(json => ({ status: 200, data: json as T }));
}

interface Recipe {
    name: string;
    origin: string;
    // ... 他のプロパティ
}

fetchItem<Recipe>("/api/recipe")
    .then(response => {
        console.log(response.data.name); // TがRecipeとして扱える
    });

type RequiredLocales = "lt" | "en" | "ja";

function createLocalizedRecipe<
    T extends { name: string; origin: string },
    U extends Record<RequiredLocales, string>
>(baseItem: T, localizedNames: U): T & { localizedNames: U } {
    return { ...baseItem, localizedNames };
}

// リトアニア発のシルケ料理データ
const silkeBase = { name: "Silkė su svogūnais", origin: "Lithuania" };
// ローカライズ辞書には必ずlt, en, jaが必要
const silkeTranslations = {
    lt: "Silkė su svogūnais",
    en: "Herring with Onions",
    ja: "ニシンの玉ねぎ添え"
} as const;
// 問題なくオブジェクトが生成される
const localizedSilke = createLocalizedRecipe(silkeBase, silkeTranslations);

// 以下はエラー（jaが欠けているため）
const cepelinaiBase = { name: "Cepelinai", origin: "Lithuania" }
const cepelinaiTranslations = {
    lt: "Didžkukuliai",
    en: "Cepelinai"
};
createLocalizedRecipe(cepelinaiBase, cepelinaiTranslations);
// Argument of type '{ lt: string; en: string; }' is not assignable to parameter of type 'Record<RequiredLocales, string>'.
// Property 'ja' is missing in type '{ lt: string; en: string; }' but required in type 'Record<RequiredLocales, string>'.

type Dish = {
  name: string;
  ingredients: string[];
  origin: string;
};

type DishKeys = keyof Dish; // "name" | "ingredients" | "origin"

function getProperty(obj: Dish, key: keyof Dish) {
  return obj[key]; // keyがTに確実に存在することが型で保証される
}

const dish: Dish = {
  name: "Koldūnai",
  ingredients: ["flour", "water", "mushrooms"],
  origin: "Lithuania"
};

// OK
const dishName = getProperty(dish, "name"); 
// "name"キーが確実に存在するため、安全

// NG
const dishColor = getProperty(dish, "color"); // コンパイルエラー：
// Argument of type '"color"' is not assignable to parameter of type 'keyof Dish'.

const dishName = "Pyragėliai";

// 値dishNameから型を取り出す
type DishNameType = typeof dishName; 
// type DishNameType = "Pyragėliai"

// 配列の定義
const dishes = ["Kibinai", "Koldūnai", "Kūčiukai"] as const;
// dishes: readonly ["Kibinai", "Koldūnai", "Kūčiukai"]
// as constがないと stirng[] になる点に注意

// 型の取得
type Dish = (typeof dishes)[number];
// Dish = "Kibinai" | "Koldūnai" | "Kūčiukai"

// ルックアップの補足
type Dish0 = (typeof dishes)[0];
// Dish0 = "Kibinai"
type Dish12 = (typeof dishes)[1 | 2];
// Dish12 = "Koldūnai" | "Kūčiukai"

const array = ["Kibinai", 1991, "Koldūnai", 1253, "Kūčiukai"];
// array: array: (string | number)[]
const filtered = array.filter((val) => typeof val === "string");
// filtered: string[] = ["Kibinai", "Koldūnai", "Kūčiukai"]

const input: unknown = "Kibinai";

console.log(input.toUpperCase()) // コンパイルエラー：
// 'input' is of type 'unknown'.

// typeof型ガードの使用
if (typeof input === "string") {
  console.log(input.toUpperCase()); // KIBINAI
}

// ユーザー定義型ガードの使用
function isString(value: unknown): value is string {
  return typeof value === "string";
}
if (isString(input)) {
  console.log(input.toUpperCase()); // KIBINAI
}

type Writable<T> = { -readonly [K in keyof T]: T[K] };

/**
 * Make all properties in T optional
 */
type Partial<T> = {
    [P in keyof T]?: T[P];
};

/**
 * Make all properties in T required
 */
type Required<T> = {
    [P in keyof T]-?: T[P];
};

/**
 * Make all properties in T readonly
 */
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

/**
 * Construct a type with a set of properties K of type T
 */
type Record<K extends keyof any, T> = {
    [P in K]: T;
};

/**
 * From T, pick a set of properties whose keys are in the union K
 */
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

/**
 * Construct a type with the properties of T except for those in type K.
 */
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

type IngredientCategory = 'vegetable' | 'grain' | 'bean' | 'other';
type IngredientTexture  = 'crunchy' | 'soft' | 'firm';
interface IngredientInfo {
    category: IngredientCategory;
    texture: IngredientTexture;
};

interface Mišrainė {
    [ingredient: string]: IngredientInfo;
}

const salad: Mišrainė = {
    beet: { category: 'vegetable', texture: 'soft' },
    bean: { category: 'bean', texture: 'firm' }
};

// 後から別の材料も追加可能
salad.cucumber = { category: 'vegetable', texture: 'crunchy' };
salad.bread = { category: 'grain', texture: 'firm' };

type IndexSignature = { [x: string]: number };
type Recorded       = Record<string, number>;
type MappedTypes = { [x in string]: number };
// いずれも { [x: string]: number; } と推論される

type Literal = ""
type IndexSignatureError = { [x: Literal]: number }; // コンパイルエラー：
// An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead.
type RecordedLieral      = Record<Literal, number>;
type MappedTypesLiteral  = { [x in Literal]: number };

interface Mišrainė {
  base?: string;
  [ingredient: string]: string | Mišrainė | undefined;
}

const mišrainė: Mišrainė = {
  base: 'じゃがいも',
  'ドレッシング': {
    base: 'マヨネーズ',
    '胡椒': '黒胡椒',
    'ハーブ': 'バジルとオレガノ'
  },
};

type Mišrainė = {
  // トマトプロパティを除外するために `tomato` を `never` に設定
  tomato?: never;
  [key: string]: any;
};

const mišrainė: Mišrainė = {
  lettuce: "fresh",
  cucumber: "crisp",
  tomato: "ripe", // コンパイルエラー：
  // Type 'string' is not assignable to type 'undefined'.
  // The expected type comes from property 'tomato' which is declared here on type 'Mišrainė'
};

// リーフノード: quantityのみを持つ
interface LeafIngredient {
  quantity: string;
};

// ネストノード: 他の具材を持ち、quantityを持たない
type NestedIngredient = {
  [ingredient: string]: Ingredient;
} & { [key in keyof LeafIngredient]? : never };

// 再帰的な型
type Ingredient = LeafIngredient | NestedIngredient;

// トップレベルではquantityを禁止
type TopLevelIngredients = {
  [K in string as K extends keyof LeafIngredient ? never : K]: Ingredient;
};

// 正しいオブジェクト例
const complexRecipe: TopLevelIngredients = {
  vegetables: {
    quantity: "500g"
  },
  marinade: {
    herbs: { quantity: "10g" },
    spices: { quantity: "5g" }
  },
  dressing: {
    base: { quantity: "100ml" },
    extras: {
      lemon: { quantity: "2 slices" },
      honey: { quantity: "1 tbsp" }
    }
  }
};

// エラーとなるオブジェクト例
const ng1: TopLevelIngredients = { 
  quantity: "1g" // コンパイルエラー（ルートにquantityは書けない）：
  // Type 'string' is not assignable to type 'Ingredient'.
  // The expected type comes from property 'quantity' which is declared here on type 'TopLevelIngredients'
}

const ng2: TopLevelIngredients = { 
  a: { 
    quantity: "1g", 
    b: {} // コンパイルエラー（'quantity' と他のプロパティを同時に持つことはできない）：
    // Object literal may only specify known properties, and 'b' does not exist in type 'LeafIngredient'.
    // The expected type comes from property 'a' which is declared here on type 'TopLevelIngredients'
  } 
}

const ng3: TopLevelIngredients = { 
  a: { 
    quantity: {a: ""}, // コンパイルエラー（quantityはstringしか書けない）：
    // Type '{ a: string; }' is not assignable to type 'string'.
    // The expected type comes from property 'quantity' which is declared here on type 'Ingredient'
  }
}

type IsDish<T> = T extends Dish ? true : false;

type Without<T, U> = T extends U ? never : T;

type Ingredients = "carrots" | "potatoes" | "tomato";

type MyIngredients = Without<Ingredients, "tomato">;
// MyIngredients = "carrots" | "potatoes"

type IsDish<T> = T extends Dish ? true : false;

type A = IsDish<Dish>;          // true
type B = IsDish<string>;        // false
type C = IsDish<Dish | string>; // boolean

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

// 使用例
interface Dish {
  name: string;
  ingredients: {
    vegetables: string[];
    meats: string[];
  };
}

type PartialDish = DeepPartial<Dish>;
/*
{
  name?: string;
  ingredients?: {
    vegetables?: string[];
    meats?: string[];
  };
}
*/

type MyReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

const bake = () => "黒パンは美味しい";

type Result = MyReturnType<typeof bake>; // Resultはstring型

/**
 * Obtain the return type of a function type
 */
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

type ElementType<T> = T extends (infer E)[] ? E : never;

type DuonaIngredients = string[];

type Ingredient = ElementType<DuonaIngredients>; // string

/**
 * Recursively unwraps the "awaited type" of a type. Non-promise "thenables" should resolve to `never`. This emulates the behavior of `await`.
 */
type Awaited<T> = T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
    T extends object & { then(onfulfilled: infer F, ...args: infer _): any; } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
        F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
            Awaited<V> : // recursively unwrap the value
        never : // the argument to `then` was not callable
    T; // non-object or non-thenable

type NestedPromiseType = Promise<Promise<number>>;
type ResolvedNestedType = Awaited<NestedPromiseType>; // number

async function fetchDuona(): Promise<{ name: string; ingredients: string[] }> {
  return {
    name: "黒ライ麦パン",
    ingredients: ["ライ麦粉", "水", "塩", "酵母"],
  };
}

type FetchDuonaReturnType = Awaited<ReturnType<typeof fetchDuona>>;
// { name: string; ingredients: string[] }

import React from 'react';

type ExtractProps<T> = T extends React.ComponentType<infer P> ? P : never;

type DuonaProps = {
  name: string;
  ingredients: string[];
};

const DuonaComponent: React.FC<DuonaProps> = ({ name, ingredients }) => (
  <div>
    <h1>{name}</h1>
    <ul>
      {ingredients.map((ingredient) => (
        <li key={ingredient}>{ingredient}</li>
      ))}
    </ul>
  </div>
);

type Props = ExtractProps<typeof DuonaComponent>; // DuonaPropsと同じ

(前略)
reactDom.createRoot(document.getElementById('root') as HTMLElement).render(
    <React.StrictMode>
        <App />
    </React.StrictMode>,
);

const response: unknown = await fetch("https://api.example.com/data");
const data = response as { name: string; age: number }; // 必要な型を明示
console.log(`名前: ${data.name}, 年齢: ${data.age}`);

const element = document.getElementById("root")!;
console.log(element.innerHTML); // null と undefined の可能性を除外

export function grayscale(imageData: Uint8ClampedArray): Uint8ClampedArray {
    const len = imageData.length;
    const result = new Uint8ClampedArray(len); // 8 ビットの符号なし整数値のビュー

    for (let i = 0; i < len; i += 4) {
        const r = imageData[i];
        const g = imageData[i + 1];
        const b = imageData[i + 2];

        const gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b) as u32; // 符号なしに修正

        result[i] = gray;
        result[i + 1] = gray;
        result[i + 2] = gray;
        result[i + 3] = imageData[i + 3];
    }

    return result;
}

const raw: unknown = "じゃがいも";
const potato: number = raw as number; // じゃがいもの実態は文字列であり、数字ではない

const potato: number = ("じゃがいも" as unknown) as number;

const raw: unknown = "じゃがいも";

if (typeof raw === "number") {
    const potato: number = raw; // 型チェック後なので安全
    console.log(`安全に数値として使用できます: ${potato}`);
} else {
    console.error("値は数値ではありません");
}

// 型アサーションあり
const potato: number = Math.round(0.299 * 255) as number;

// 型アサーションなし
const potato = Math.round(0.299 * 255); // 自動推論される！