类型工具

let num: number = 123
let str: string = "hello"
let bool: boolean = true
let big: bigint = 123n
let sym: symbol = Symbol("desc")
let undef: undefined = undefined
let nul: null = null

type Tuple = [number, string]

const tuple: Tuple = [1, "hello"] // OK
// tuple[0] 是 number 类型
// tuple[1] 是 string 类型

// 带可选元素的元组
type OptionalTuple = [string, number?]
const t1: OptionalTuple = ["hello"]
const t2: OptionalTuple = ["hello", 123]

interface IPerson {
  name: string
  age: number
}

class Person implements IPerson {
  name: string
  age: number
}

const obj: IPerson = {
  name: "guang",
  age: 18
}

interface SayHello {
  (name: string): string
}

const func: SayHello = (name: string) => {
  return "hello," + name
}

interface PersonConstructor {
  new (name: string, age: number): IPerson
}

function createPerson(ctor: PersonConstructor): IPerson {
  return new ctor("guang", 18)
}

interface IPerson {
  [prop: string]: string | number
}

const obj: IPerson = {}
obj.name = "guang"
obj.age = 18

enum Transpiler {
  Babel = "babel",
  Postcss = "postcss",
  Terser = "terser",
  Prettier = "prettier",
  TypeScriptCompiler = "tsc"
}

const transpiler = Transpiler.TypeScriptCompiler // "tsc"

// 数字枚举（自动递增）
enum Direction {
  Up, // 0
  Down, // 1
  Left, // 2
  Right // 3
}

// 混合枚举
enum BooleanLikeHeterogeneousEnum {
  No = 0,
  Yes = "YES"
}

type NumLiteral = 123
type StrLiteral = "hello"
type BoolLiteral = true

const a: 123 = 123 // OK
// const b: 123 = 124 // Error

type Greeting = `hello${string}`

const g1: Greeting = "hello world" // OK
const g2: Greeting = "hello" // OK
// const g3: Greeting = "hi world" // Error

type HttpMethod = "GET" | "POST" | "PUT" | "DELETE"
type ApiPath = `/api/${string}`
type Endpoint = `${HttpMethod} ${ApiPath}`

const endpoint: Endpoint = "GET /api/users" // OK
// const bad: Endpoint = "PATCH /api/users" // Error

// never：永不存在的类型
function throwError(message: string): never {
  throw new Error(message)
}

function infiniteLoop(): never {
  while (true) {}
}

// void：函数没有返回值
function log(message: string): void {
  console.log(message)
}

// any：放弃类型检查
let anything: any = "hello"
anything = 123 // OK
anything.foo() // OK（但运行时可能报错）

// unknown：类型安全的 any
let unknown: unknown = "hello"
unknown = 123 // OK
// unknown.toFixed() // Error：不能直接使用
if (typeof unknown === "number") {
  unknown.toFixed() // OK：类型收窄后可用
}

interface IPerson {
  readonly name: string // 只读属性
  age?: number // 可选属性
}

type tuple = [string, number?] // 可选元素的元组

type res = 1 extends 2 ? true : false; // false

type isTwo<T> = T extends 2 ? true : false;

type res1 = isTwo<1>; // false
type res2 = isTwo<2>; // true

type First<Tuple extends unknown[]> = Tuple extends [infer T, ...infer R] ? T : never;

type res = First<[1, 2, 3]>; // 1

type Union = 1 | 2 | 3;

type ObjType = { a: number } & { c: boolean };
// 结果: { a: number; c: boolean }

type MapType<T> = {
  [Key in keyof T]?: T[Key]
}

type MapType<T> = {
    [
        Key in keyof T 
            as `${Key & string}${Key & string}${Key & string}`
    ]: [T[Key], T[Key], T[Key]]
}

type StatusCode = 200 | 301 | 400 | 500 | 502
type PossibleDataTypes = string | number | (() => unknown)

const status: StatusCode = 502

type Handler = (e: Event) => void

const clickHandler: Handler = (e) => {
  /* ... */
}
const moveHandler: Handler = (e) => {
  /* ... */
}

type UserProfile = {
  name: string
  age: number
  isActive: boolean
}

type Factory<T> = T | number | string

// "调用"类型函数，传入 boolean
type FactoryWithBool = Factory<boolean> // 得到 boolean | number | string

const foo: FactoryWithBool = true

type Maybe<T> = T | null | undefined

function process(input: Maybe<{ handler: () => {} }>) {
  // input 可能是 null 或 undefined，必须使用可选链 ?.
  input?.handler()
}

type MaybeArray<T> = T | T[]

// 这个函数确保返回值总是一个数组
function ensureArray<T>(input: MaybeArray<T>): T[] {
  return Array.isArray(input) ? input : [input]
}

type ApiResponse<T> = {
  data: T
  isSuccess: boolean
  errorMessage?: string
}

type UserResponse = ApiResponse<{ name: string; age: number }>
const response: UserResponse = {
  data: { name: "xiaoye", age: 18 },
  isSuccess: true
}

type ArticleResponse = ApiResponse<{ title: string; content: string }>

// interface 支持声明合并
interface Config {
  host: string
}

interface Config {
  port: number
}

const config: Config = {
  host: 'localhost',
  port: 3000
}

// type 不支持声明合并
type ConfigType = {
  host: string
}

// Error: Duplicate identifier 'ConfigType'
// type ConfigType = {
//   port: number
// }

interface Struct1 {
  primitiveProp: string;
}

interface Struct1 {
  // Error: 后续属性声明必须属于同一类型
  // 属性"primitiveProp"的类型必须为"string"，但此处却为类型"number"
  primitiveProp: number;
}

type Base = {
  name: string;
};

interface IDerived extends Base {
  // Error: 就像继承接口一样需要类型兼容
  name: number;
  age: number;
}

interface IBase {
  name: string;
}

// 合并后的 name 是 never 类型（string & number = never）
type Derived = IBase & {
  name: number;
};

// type 可以表示更复杂的类型
type ID = string | number // 联合类型
type Tuple = [string, number] // 元组类型
type Readonly<T> = {
  // 映射类型
  readonly [K in keyof T]: T[K]
}

// interface 只能描述对象形状
interface IUser {
  name: string
  age: number
}

let a: string | number

a = "hello" // OK
a = 123 // OK

a = true // Error: Type 'boolean' is not assignable to type 'string | number'.

function formatId(id: string | number) {
  // Inside the function, we need to narrow the type
  if (typeof id === "string") {
    return id.toUpperCase()
  } else {
    return id.toFixed(2)
  }
}

// 字面量联合类型：表示有限的状态
type Status = 'pending' | 'approved' | 'rejected'
type Role = 'admin' | 'user' | 'guest'

// 类型收窄示例
function process(value: string | number | boolean) {
  if (typeof value === 'string') {
    // value 的类型收窄为 string
    return value.toUpperCase()
  } else if (typeof value === 'number') {
    // value 的类型收窄为 number
    return value.toFixed(2)
  } else {
    // value 的类型收窄为 boolean
    return value ? 'true' : 'false'
  }
}

interface NameStruct {
  name: string
}

interface AgeStruct {
  age: number
}

type ProfileStruct = NameStruct & AgeStruct

const profile: ProfileStruct = {
  name: "xiaoye",
  age: 18
} // OK, it has both name and age

type StrAndNum = string & number // Type is never

type Struct1 = {
  primitiveProp: string
  objectProp: {
    name: string
  }
}

type Struct2 = {
  primitiveProp: number
  objectProp: {
    age: number
  }
}

type Composed = Struct1 & Struct2

type PrimitivePropType = Composed["primitiveProp"] // never
type ObjectPropType = Composed["objectProp"] // { name: string; age: number; }

const composedVar: Composed = {
  // Type 'string' is not assignable to type 'never'.
  primitiveProp: "hello",
  objectProp: {
    name: "xiaoye",
    age: 18
  }
}

type UnionA = "a" | "b" | "c"
type UnionB = "b" | "c" | "d"

// Result is 'b' | 'c'
type IntersectionOfUnions = UnionA & UnionB

interface BaseConfig {
  theme: "light" | "dark"
  responsive: boolean
}

interface ExtendedConfig {
  animations: boolean
  lazyLoad: boolean
}

type FullConfig = BaseConfig & ExtendedConfig

function createComponent(config: FullConfig) {
  console.log(`Theme: ${config.theme}`)
  console.log(`Animations: ${config.animations}`)
}

// We can also use it for partial updates
function updateConfig(current: FullConfig, patch: Partial<FullConfig>): FullConfig {
  return { ...current, ...patch }
}

interface StringMap {
  [key: string]: string
}

const myMap: StringMap = {}
myMap.foo = "bar"
myMap.anyKey = "anyValue"

const value: string = myMap.whatever // OK, a string

interface MixedType {
  propA: number // OK, number is a subtype of number | boolean
  propB: boolean
  [key: string]: number | boolean

  // Error: Property 'propC' of type 'string' is not assignable
  // to 'string' index type 'number | boolean'.
  propC: string
}

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

type UserKeys = keyof User // "id" | "name" | "email"

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

type UserIdType = User["id"] // number
type UserNameType = User["name"] // string

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

type UserValues = User[keyof User] // string | number

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

const user: User = { id: 1, name: "xiaoye", email: "test@test.com" }

const userName = getProperty(user, "name") // Type is string
const userId = getProperty(user, "id") // Type is number

// Error: Argument of type '"age"' is not assignable to parameter of type 'keyof User'.
const userAge = getProperty(user, "age")

type MappedType<T> = {
  [K in keyof T]: NewType
}

type Clone<T> = {
  [K in keyof T]: T[K]
}

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

// 使用
interface User {
  name: string
  age: number
}

const readonlyUser: MyReadonly<User> = { name: "xiaoye", age: 18 }
readonlyUser.name = "new name" // Error: Cannot assign to 'name' because it is a read-only property.

type MyPartial<T> = {
  [K in keyof T]?: T[K]
}

// 使用
const partialUser: MyPartial<User> = {} // OK
const partialUser2: MyPartial<User> = { name: "xiaoye" } // OK

type MyRequired<T> = {
  [K in keyof T]-?: T[K]
}

interface UserWithOptional {
  name: string
  age?: number
}

// Error: Property 'age' is missing in type '{ name: string; }' but required in type 'MyRequired<UserWithOptional>'.
const requiredUser: MyRequired<UserWithOptional> = { name: "xiaoye" }

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

const mutableUser: Mutable<MyReadonly<User>> = { name: "xiaoye", age: 18 }
mutableUser.name = "new name" // OK

type Getter<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
}

interface User {
  name: string
  age: number
}

type UserGetter = Getter<User>

// 等价于：
// type UserGetter = {
//   getName: () => string;
//   getAge: () => number;
// }

type PickStringProps<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K]
}

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

type StringPropsOnly = PickStringProps<User>

// 等价于：
// type StringPropsOnly = {
//   name: string;
//   email: string;
// }

type res = 1 extends 2 ? true : false // false

type IsTwo<T> = T extends 2 ? true : false

type res1 = IsTwo<1> // false
type res2 = IsTwo<2> // true

// 判断是否为字符串类型
type IsString<T> = T extends string ? true : false

type A = IsString<"hello"> // true
type B = IsString<123> // false

// 根据类型返回不同的值类型
type ResultType<T> = T extends string
  ? { value: string }
  : T extends number
  ? { value: number }
  : { value: unknown }

type StringResult = ResultType<"hello"> // { value: string }
type NumberResult = ResultType<123> // { value: number }

// 提取元组的第一个元素类型
type First<Tuple extends unknown[]> = Tuple extends [infer T, ...infer R] ? T : never

type res1 = First<[1, 2, 3]> // 1
type res2 = First<[string, number]> // string

// 提取函数的返回值类型
type GetReturnType<T> = T extends (...args: any[]) => infer R ? R : never

type ReturnTypeOf = GetReturnType<() => string> // string

// 提取函数的参数类型
type GetParameters<T> = T extends (...args: infer P) => any ? P : never

type ParamsOf = GetParameters<(a: string, b: number) => void> // [a: string, b: number]

// 提取 Promise 的内部类型
type Unpacked<T> = T extends Promise<infer U> ? U : T

type PromiseContent = Unpacked<Promise<string>> // string
type NormalType = Unpacked<number> // number

// 高级类型：传入类型参数，经过运算返回新类型
type IsNever<T> = [T] extends [never] ? true : false

type A = IsNever<never> // true
type B = IsNever<string> // false

const str = "xiaoye"
const obj = { name: "xiaoye" }
const nullVar = null
const undefinedVar = undefined
const func = (input: string) => {
  return input.length > 10
}

// 从变量中提取类型
type Str = typeof str // "xiaoye"
type Obj = typeof obj // { name: string; }
type Null = typeof nullVar // null
type Undefined = typeof undefined // undefined
type Func = typeof func // (input: string) => boolean

const func = (input: string) => {
  return input.length > 10
}

// 获取函数 func 的返回值类型
type FuncReturnType = ReturnType<typeof func> // boolean

// 获取函数 func 的参数类型
type FuncParametersType = Parameters<typeof func> // [input: string]

const isInputValid = (input: string) => {
  return input.length > 10;
};

// ❌ 错误：不允许在 typeof 后使用表达式
let isValid: typeof isInputValid("xiaoye");

function foo(input: string | number) {
  if (typeof input === "string") {
    // TypeScript 在此分支中知道 input 是 string 类型
  }
  if (typeof input === "number") {
    // TypeScript 在此分支中知道 input 是 number 类型
  }
  // ...
}

function isString(input: unknown): boolean {
  return typeof input === "string"
}

function foo(input: string | number) {
  if (isString(input)) {
    // ❌ 错误：类型"string | number"上不存在属性"replace"。
    // TypeScript 无法将 isString 的返回结果与 input 的类型关联起来
    input.replace("xiaoye", "xiaoye599")
  }
  // ...
}

// 这个函数就是一个类型守卫
function isString(input: unknown): input is string {
  return typeof input === "string"
}

function foo(input: string | number) {
  if (isString(input)) {
    // ✅ 正确：TypeScript 知道这里的 input 是 string 类型
    input.replace("xiaoye", "xiaoye599")
  }
  // ...
}

// 这是一个错误的类型守卫，会误导 TypeScript
function isStringButActuallyNumber(input: unknown): input is number {
  // 逻辑上判断的是 string，但类型上声明的是 number
  return typeof input === "string"
}

function foo(input: string | number) {
  if (isStringButActuallyNumber(input)) {
    // ❌ 运行时错误：input.toFixed is not a function
    // TypeScript 认为 input 是 number，但实际上它可能是 string
    input.toFixed()
  }
}

export type Falsy = false | "" | 0 | null | undefined

export const isFalsy = (val: unknown): val is Falsy => !val

// 一个更具体的守卫，只检查 null 和 undefined
export const isNil = (val: unknown): val is null | undefined =>
  val === null || val === undefined

const arr = [1, 2, null, 3, undefined, 4]

// 使用 isNil 守卫过滤掉 null 和 undefined
const nonNilArr = arr.filter((item): item is number => !isNil(item)) // number[]

// 如果没有类型守卫，filter 后的类型仍然是 (number | null | undefined)[]
const stillMixedArr = arr.filter((item) => !isNil(item)) // (number | null | undefined)[]

interface Foo {
  foo: string
  fooOnly: boolean
  shared: number
}

interface Bar {
  bar: string
  barOnly: boolean
  shared: number
}

function handle(input: Foo | Bar) {
  if ("foo" in input) {
    // ✅ 正确：TypeScript 知道 input 是 Foo 类型
    input.fooOnly
  } else {
    // ✅ 正确：TypeScript 知道 input 是 Bar 类型
    input.barOnly
  }
}

function handle(input: Foo | Bar) {
  if ("shared" in input) {
    // ❌ 错误：input 仍然是 Foo | Bar 类型
    input.fooOnly
  } else {
    // 这里的 input 是 never 类型
    input.barOnly
  }
}

interface Foo {
  kind: "foo" // 可辨识属性
  diffType: string
  fooOnly: boolean
}

interface Bar {
  kind: "bar" // 可辨识属性
  diffType: number
  barOnly: boolean
}

function handle(input: Foo | Bar) {
  if (input.kind === "foo") {
    // ✅ 正确：TypeScript 知道 input 是 Foo 类型
    input.fooOnly
  } else {
    // ✅ 正确：TypeScript 知道 input 是 Bar 类型
    input.barOnly
  }
}

class FooBase {}
class BarBase {}

class Foo extends FooBase {
  fooOnly() {}
}
class Bar extends BarBase {
  barOnly() {}
}

function handle(input: Foo | Bar) {
  if (input instanceof FooBase) {
    // ✅ 正确：TypeScript 知道 input 是 Foo 类型
    input.fooOnly()
  } else {
    // ✅ 正确：TypeScript 知道 input 是 Bar 类型
    input.barOnly()
  }
}

// `asserts condition` 表示，如果函数成功返回，那么 condition 一定为真
function assert(condition: any, msg?: string): asserts condition {
  if (!condition) {
    throw new Error(msg)
  }
}

let name: any = "xiaoye"

// 在这里，TypeScript 并不知道 name 的类型
assert(typeof name === "number")

// ✅ 正确：通过断言后，TypeScript 知道 name 是 number 类型
name.toFixed()

function assertIsNumber(val: any): asserts val is number {
  if (typeof val !== "number") {
    throw new Error("Not a number!")
  }
}

let name: any = "xiaoye"

assertIsNumber(name)

// ✅ 正确：通过断言后，TypeScript 知道 name 是 number 类型
name.toFixed() // 在运行时会抛出 "Not a number!" 错误

// ❌ 不推荐：命名过于抽象
type T1 = string | number
type T2 = { a: string; b: number }

// ✅ 推荐：使用语义化的命名
type UserID = string | number
type UserProfile = {
  name: string
  age: number
}

// ✅ 使用泛型约束确保类型安全
type ApiResponse<T extends object> = {
  data: T
  success: boolean
  message?: string
}

// 这样可以防止传入原始类型
type Response = ApiResponse<string> // Error: 类型不满足约束

// ✅ 联合类型：表示互斥的状态
type LoadingState = { status: 'loading' }
type SuccessState = { status: 'success'; data: string }
type ErrorState = { status: 'error'; error: Error }
type AppState = LoadingState | SuccessState | ErrorState

// ✅ 交叉类型：合并配置
type BaseOptions = { debug: boolean }
type LoggerOptions = { logLevel: 'info' | 'warn' | 'error' }
type NetworkOptions = { timeout: number }

type AllOptions = BaseOptions & LoggerOptions & NetworkOptions

// ❌ 不推荐：重复造轮子
type MyPartial<T> = {
  [K in keyof T]?: T[K]
}

// ✅ 推荐：组合使用内置工具类型
type OptionalUser = Partial<User>
type ReadonlyUser = Readonly<User>
type UserKeys = keyof User
type UserValues = User[keyof User]

// utils/type-guards.ts
export const isString = (val: unknown): val is string => typeof val === 'string'
export const isNumber = (val: unknown): val is number => typeof val === 'number'
export const isObject = (val: unknown): val is Record<string, unknown> =>
  typeof val === 'object' && val !== null
export const isArray = <T>(val: unknown): val is T[] => Array.isArray(val)

// 使用
import { isString, isNumber } from './utils/type-guards'

function process(value: unknown) {
  if (isString(value)) {
    // value 是 string
  } else if (isNumber(value)) {
    // value 是 number
  }
}

// ⚠️ 陷阱：同名属性类型冲突会导致 never
type Conflict = { a: string } & { a: number }
// a 的类型是 never，无法赋值

// ✅ 解决方案：使用不同的属性名
type Safe = { str: string } & { num: number }

// ⚠️ 陷阱：直接检查联合类型会导致分发
type ToArray<T> = T extends any ? T[] : never
type Result = ToArray<string | number> // string[] | number[]

// ✅ 如果想要 (string | number)[]，需要使用元组
type ToArray2<T> = T[]
type Result2 = ToArray2<string | number> // (string | number)[]

// ⚠️ 陷阱：错误的类型守卫实现
function isUser(val: unknown): val is User {
  // ❌ 只检查了一个属性，不够严格
  return typeof val === 'object' && val !== null && 'name' in val
}

// ✅ 正确的实现：检查所有必需属性
function isUser(val: unknown): val is User {
  return (
    typeof val === 'object' &&
    val !== null &&
    'name' in val &&
    typeof (val as User).name === 'string' &&
    'age' in val &&
    typeof (val as User).age === 'number'
  )
}

// ⚠️ 陷阱：索引签名与具体属性类型不兼容
interface BadExample {
  name: string
  [key: string]: number // Error: name 是 string，与 number 不兼容
}

// ✅ 解决方案：让具体属性兼容索引签名
interface GoodExample {
  name: string
  [key: string]: string | number
}

// ⚠️ 陷阱：映射类型会保留可选性
interface Original {
  a: string
  b?: number
}

type Mapped = {
  [K in keyof Original]: Original[K] | boolean
}
// b 仍然是可选的

// ✅ 使用 -? 修饰符强制必选
type MappedRequired = {
  [K in keyof Original]-?: Original[K] | boolean
}

// 定义事件映射
interface EventMap {
  click: { x: number; y: number }
  focus: { target: HTMLElement }
  input: { value: string }
}

// 类型安全的事件发射器
class TypedEventEmitter<T extends Record<string, any>> {
  private listeners: {
    [K in keyof T]?: ((payload: T[K]) => void)[]
  } = {}

  on<K extends keyof T>(event: K, listener: (payload: T[K]) => void) {
    if (!this.listeners[event]) {
      this.listeners[event] = []
    }
    this.listeners[event]!.push(listener)
  }

  emit<K extends keyof T>(event: K, payload: T[K]) {
    const eventListeners = this.listeners[event]
    if (eventListeners) {
      eventListeners.forEach(listener => listener(payload))
    }
  }

  off<K extends keyof T>(event: K, listener: (payload: T[K]) => void) {
    const eventListeners = this.listeners[event]
    if (eventListeners) {
      const index = eventListeners.indexOf(listener)
      if (index > -1) {
        eventListeners.splice(index, 1)
      }
    }
  }
}

// 使用示例
const emitter = new TypedEventEmitter<EventMap>()

emitter.on('click', (payload) => {
  console.log(`Clicked at (${payload.x}, ${payload.y})`)
})

emitter.emit('click', { x: 100, y: 200 }) // ✅ 类型安全
// emitter.emit('click', { x: '100' }) // ❌ 类型错误

// 深层 Partial
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
}

// 深层 Required
type DeepRequired<T> = {
  [K in keyof T]-?: T[K] extends object ? DeepRequired<T[K]> : T[K]
}

// 使用示例
interface Config {
  server: {
    host: string
    port: number
    options: {
      ssl: boolean
      timeout: number
    }
  }
  database: {
    host: string
    name: string
  }
}

const partialConfig: DeepPartial<Config> = {
  server: {
    options: {
      ssl: true
    }
  }
}

const requiredConfig: DeepRequired<Config> = {
  server: {
    host: 'localhost',
    port: 3000,
    options: {
      ssl: false,
      timeout: 5000
    }
  },
  database: {
    host: 'localhost',
    name: 'mydb'
  }
}

// 定义路由配置
interface RouteConfig {
  home: {
    path: '/'
    params: {}
  }
  user: {
    path: '/user/:id'
    params: { id: string }
  }
  post: {
    path: '/post/:postId/comment/:commentId'
    params: { postId: string; commentId: string }
  }
}

// 提取路径参数的类型
type ExtractParams<T extends string> = T extends `${infer _}:${infer Param}/${infer Rest}`
  ? { [K in Param]: string } & ExtractParams<Rest>
  : T extends `${infer _}:${infer Param}`
  ? { [K in Param]: string }
  : {}

// 类型安全的路由导航
function navigate<K extends keyof RouteConfig>(
  route: K,
  params: RouteConfig[K]['params']
) {
  let path: string = RouteConfig[route].path

  // 替换路径参数
  Object.keys(params).forEach(key => {
    path = path.replace(`:${key}`, (params as any)[key])
  })

  console.log(`Navigating to: ${path}`)
}

// 使用示例
navigate('home', {}) // ✅
navigate('user', { id: '123' }) // ✅
// navigate('user', {}) // ❌ 缺少 id 参数
// navigate('user', { id: 123 }) // ❌ id 必须是 string

// 获取对象深层路径的类型
type PathValue<T, P extends string> = P extends `${infer K}.${infer Rest}`
  ? K extends keyof T
    ? PathValue<T[K], Rest>
    : never
  : P extends keyof T
  ? T[P]
  : never

// 获取对象所有可能的路径
type Path<T> = T extends object
  ? {
      [K in keyof T]: K extends string
        ? T[K] extends object
          ? K | `${K}.${Path<T[K]>}`
          : K
        : never
    }[keyof T]
  : never

// 类型安全的 get 函数
function get<T, P extends Path<T>>(obj: T, path: P): PathValue<T, P> {
  return path.split('.').reduce((acc: any, key) => acc?.[key], obj)
}

// 使用示例
const obj = {
  a: {
    b: {
      c: 'hello'
    },
    d: 123
  },
  e: true
}

const value1 = get(obj, 'a.b.c') // string
const value2 = get(obj, 'a.d') // number
const value3 = get(obj, 'e') // boolean
// const value4 = get(obj, 'a.b.x') // ❌ 类型错误：路径不存在