typescript相对完备

// 基本字符串
let name: string = "opencode"
let greeting: string = 'hello'

// 模板字符串（Template Literal）
let message: string = `Hello, ${name}!`

// 多行字符串
let multiline: string = `
  This is a
  multiline string
`

// TypeScript中所有数字都是浮点数
let age: number = 42
let price: number = 99.99

// 不同进制的数字
let hex: number = 0xf00d      // 十六进制
let binary: number = 0b1010   // 二进制
let octal: number = 0o744     // 八进制

// 特殊数值
let notANumber: number = NaN
let infinity: number = Infinity

let isActive: boolean = true
let isCompleted: boolean = false

// 布尔值通常来自比较运算
let isGreater: boolean = 10 > 5  // true
let isEqual: boolean = "a" === "b"  // false

let nothing: null = null
let notDefined: undefined = undefined

// 重要概念：strictNullChecks
// 当tsconfig.json中启用strictNullChecks时：
// null和undefined是独立类型，不能赋值给其他类型

let value: string = "hello"
// value = null  // 错误！（strictNullChecks开启时）
// value = undefined  // 错误！（strictNullChecks开启时）

// 如果需要允许null或undefined，使用联合类型
let nullable: string | null = "hello"
nullable = null  // 正确

let optional: string | undefined = "hello"
optional = undefined  // 正确

// Symbol创建唯一的标识符
let sym1: symbol = Symbol("key")
let sym2: symbol = Symbol("key")

// 即使描述相同，每个symbol都是唯一的
console.log(sym1 === sym2)  // false

// Symbol常用于对象的唯一属性键
const uniqueKey = Symbol("id")
let obj = {
  [uniqueKey]: 12345
}

// bigint用于表示超过Number.MAX_SAFE_INTEGER的整数
let big: bigint = 100n  // 注意：数字后面加n
let huge: bigint = BigInt("9007199254740991")

// Number.MAX_SAFE_INTEGER = 9007199254740991
// 超过这个值的整数运算可能不精确

// bigint和number不能混合运算
let num: number = 100
let bigNum: bigint = 100n
// let result = num + bigNum  // 错误！

// 来自 packages/opencode/src/session/index.ts
export namespace Session {
  export const Info = z.object({
    id: Identifier.schema("session"),  // string类型
    slug: z.string(),
    projectID: z.string(),
    time: z.object({
      created: z.number(),    // 时间戳用number
      updated: z.number(),
      archived: z.number().optional(),
    }),
  })
}

// 方式1：类型[]（推荐）
let numbers: number[] = [1, 2, 3, 4, 5]
let strings: string[] = ["a", "b", "c"]
let booleans: boolean[] = [true, false, true]

// 方式2：Array<类型>（泛型写法）
let numbers2: Array<number> = [1, 2, 3]
let strings2: Array<string> = ["a", "b", "c"]

// 两种写法完全等价，推荐使用第一种（更简洁）

// readonly修饰符防止数组被修改
let readonlyArr: readonly number[] = [1, 2, 3]
let readonlyArr2: ReadonlyArray<number> = [1, 2, 3]

// 不能修改只读数组
// readonlyArr.push(4)     // 错误！
// readonlyArr[0] = 10     // 错误！
// readonlyArr.pop()       // 错误！

// 但可以读取
console.log(readonlyArr[0])  // 正确
console.log(readonlyArr.length)  // 正确

// 可以通过解构创建新数组
let newArr = [...readonlyArr, 4]  // 正确

// 二维数组
let matrix: number[][] = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]

// 三维数组
let cube: number[][][] = [
  [[1, 2], [3, 4]],
  [[5, 6], [7, 8]]
]

// 访问元素
let element = matrix[0][1]  // 2

// 数组元素可以是多种类型
let mixed: (string | number)[] = [1, "two", 3, "four"]

// 注意括号的位置
let arr1: string | number[]  // string 或 number数组
let arr2: (string | number)[]  // (string或number)的数组

// 复杂的联合类型数组
type Status = "pending" | "completed"
let statuses: Status[] = ["pending", "completed"]

// 来自 packages/opencode/src/session/message-v2.ts
export namespace MessageV2 {
  // parts是一个Part类型的数组
  export interface WithParts {
    parts: Part[]  // Part[]表示Part类型的数组
  }

  // 过滤压缩的消息
  export async function filterCompacted(
    messages: WithParts[]  // WithParts类型的数组
  ): Promise<WithParts[]> {
    return messages.filter(m => !m.parts.some(p => p.type === "compaction"))
  }
}

// 元组：[类型1, 类型2, ...]
let tuple: [string, number] = ["age", 42]

// 访问元素时，TypeScript知道每个位置的类型
let name: string = tuple[0]  // string
let age: number = tuple[1]   // number

// 错误的赋值
// tuple = [42, "age"]  // 错误！类型顺序不对
// tuple = ["age"]      // 错误！长度不对

// 使用 ? 表示可选元素
let tuple1: [string, number?] = ["name"]  // 第二个元素可选
let tuple2: [string, number?] = ["name", 30]

// 可选元素必须在必需元素之后
// let invalid: [string?, number] = [undefined, 42]  // 错误！

// 使用 ...类型[] 表示剩余元素
let tuple1: [string, ...number[]] = ["items", 1, 2, 3, 4, 5]
let tuple2: [string, ...number[]] = ["items"]  // 剩余元素可以为空

// 剩余元素必须在最后
// let invalid: [...number[], string] = [1, 2, "end"]  // 错误！

// 复杂的剩余元素
let tuple3: [boolean, ...string[], number] = [true, "a", "b", "c", 42]

// 命名元组：[名称: 类型, ...]
type Range = [start: number, end: number]
type Point = [x: number, y: number, z?: number]
type RGB = [red: number, green: number, blue: number]

let range: Range = [0, 100]
let point: Point = [10, 20]
let color: RGB = [255, 128, 0]

// 名称只是提示，不影响使用
let start = range[0]  // 仍然通过索引访问

// 来自 packages/opencode/src/session/message-v2.ts
export namespace MessageV2 {
  // 时间范围可以用元组表示
  export interface Part {
    time?: {
      start: number
      end?: number
    }
  }

  // 可以简化为命名元组
  type TimeRange = [start: number, end?: number]

  // 使用示例
  let executionTime: TimeRange = [Date.now()]
  let completedTime: TimeRange = [Date.now(), Date.now() + 1000]
}

// 直接在变量声明中定义对象类型
let person: { name: string; age: number } = {
  name: "Alice",
  age: 30
}

// 多行写法（推荐）
let user: {
  name: string
  age: number
  email: string
} = {
  name: "Bob",
  age: 25,
  email: "bob@example.com"
}

// 使用 ? 表示属性可选
let user: {
  name: string
  age?: number      // 可选属性
  email?: string
} = {
  name: "Bob"  // age和email可以不提供
}

// 访问可选属性时需要检查
if (user.age !== undefined) {
  console.log(user.age)
}

// 或使用可选链（Optional Chaining）
console.log(user.age?.toFixed(2))

// 使用 readonly 防止属性被修改
let config: {
  readonly apiKey: string
  timeout: number
} = {
  apiKey: "secret-key",
  timeout: 5000
}

// config.apiKey = "new-key"  // 错误！只读属性不能修改
config.timeout = 10000        // 正确

// readonly只在编译时检查，运行时仍可修改
// 这是TypeScript的类型系统限制

// 基本索引签名
let scores: { [studentName: string]: number } = {
  "Alice": 95,
  "Bob": 87,
  "Charlie": 92
}

// 可以添加任意string类型的键
scores["David"] = 88
scores["Eve"] = 91

// 数字索引签名
let items: { [index: number]: string } = {
  0: "first",
  1: "second",
  2: "third"
}

// 混合使用固定属性和索引签名
let config: {
  name: string           // 固定属性
  [key: string]: any    // 索引签名
} = {
  name: "MyConfig",
  timeout: 5000,
  retries: 3
}

// 来自 packages/opencode/src/session/index.ts
export namespace Session {
  export const Info = z.object({
    id: Identifier.schema("session"),
    slug: z.string(),
    projectID: z.string(),
    directory: z.string(),
    parentID: Identifier.schema("session").optional(),  // 可选
    time: z.object({
      created: z.number(),
      updated: z.number(),
      compacting: z.number().optional(),  // 可选
      archived: z.number().optional(),    // 可选
    }),
  })
}

// 来自 packages/opencode/src/tool/tool.ts
export namespace Tool {
  // 工具的元数据使用索引签名
  export type Metadata = {
    [key: string]: any
  }
}

// 为原始类型创建别名
type ID = string | number
type Status = "active" | "inactive" | "pending"
type Count = number

// 使用类型别名
let userId: ID = "user-123"
let accountId: ID = 12345
let status: Status = "active"

// 为对象类型创建别名
type Point = {
  x: number
  y: number
}

type User = {
  id: ID
  name: string
  status: Status
  createdAt: number
}

// 使用类型别名
let point: Point = { x: 10, y: 20 }
let user: User = {
  id: "123",
  name: "Alice",
  status: "active",
  createdAt: Date.now()
}

// 为函数类型创建别名
type Handler = (input: string) => void
type Callback = (error: Error | null, result?: any) => void
type Predicate<T> = (value: T) => boolean

// 使用函数类型别名
const handleInput: Handler = (input) => {
  console.log(input)
}

const isPositive: Predicate<number> = (value) => {
  return value > 0
}

// 泛型类型别名
type Container<T> = {
  value: T
}

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

// 使用泛型类型别名
let stringContainer: Container<string> = { value: "hello" }
let numberContainer: Container<number> = { value: 42 }

let successResult: Result<string> = {
  success: true,
  data: "Success!"
}

let errorResult: Result<string> = {
  success: false,
  error: new Error("Failed")
}

// 来自 packages/opencode/src/id/id.ts
export namespace Identifier {
  export type ID = string

  export function schema(prefix: string): z.ZodString {
    return z.string()
  }
}

// 来自 packages/opencode/src/session/index.ts
export namespace Session {
  // 类型别名简化复杂类型
  export type Info = z.output<typeof Info>
  export type ShareInfo = z.output<typeof ShareInfo>
}

// 来自 packages/opencode/src/provider/provider.ts
export namespace Provider {
  export type Model = {
    id: string
    providerID: string
    contextWindow: number
    maxOutput: number
    capabilities: {
      streaming: boolean
      tools: boolean
      vision: boolean
    }
  }
}

// 基本接口定义
interface User {
  id: string
  name: string
  email: string
}

// 使用接口
let user: User = {
  id: "123",
  name: "Alice",
  email: "alice@example.com"
}

// 接口可以描述任何对象结构
interface Point {
  x: number
  y: number
}

interface Rectangle {
  topLeft: Point
  bottomRight: Point
}

// 可选属性
interface Config {
  apiKey: string
  timeout?: number     // 可选
  retries?: number     // 可选
  debug?: boolean      // 可选
}

let config1: Config = { apiKey: "key" }  // 正确
let config2: Config = {
  apiKey: "key",
  timeout: 5000,
  debug: true
}  // 正确

// 只读属性
interface Point {
  readonly x: number
  readonly y: number
}

let point: Point = { x: 10, y: 20 }
// point.x = 30  // 错误！只读属性不能修改

// 混合使用
interface User {
  readonly id: string      // 只读
  name: string             // 可修改
  email?: string           // 可选
  readonly createdAt: number  // 只读
}

// 接口可以描述函数类型
interface SearchFunc {
  (query: string, limit: number): Promise<string[]>
}

// 实现接口
const search: SearchFunc = async (query, limit) => {
  // 实现搜索逻辑
  return []
}

// 带属性的函数接口
interface Counter {
  (start: number): string  // 函数签名
  interval: number         // 属性
  reset(): void           // 方法
}

function createCounter(): Counter {
  const counter = ((start: number) => {
    return `Count: ${start}`
  }) as Counter

  counter.interval = 1000
  counter.reset = () => {
    console.log("Reset")
  }

  return counter
}

// 字符串索引签名
interface StringMap {
  [key: string]: string
}

let map: StringMap = {
  name: "Alice",
  city: "NYC"
}

map["country"] = "USA"  // 可以添加任意string键

// 数字索引签名
interface NumberArray {
  [index: number]: string
}

let arr: NumberArray = ["a", "b", "c"]

// 混合固定属性和索引签名
interface Dictionary {
  length: number           // 固定属性
  [key: string]: any      // 索引签名
}

// 注意：固定属性的类型必须是索引签名类型的子类型
interface ValidDict {
  length: number
  [key: string]: number | string  // length的number类型是这个联合类型的子类型
}

// 单继承
interface Animal {
  name: string
  age: number
}

interface Dog extends Animal {
  breed: string
  bark(): void
}

let dog: Dog = {
  name: "Buddy",
  age: 3,
  breed: "Golden Retriever",
  bark() {
    console.log("Woof!")
  }
}

// 多重继承
interface Flyable {
  fly(): void
  altitude: number
}

interface Swimmable {
  swim(): void
  depth: number
}

interface Duck extends Flyable, Swimmable {
  quack(): void
}

let duck: Duck = {
  fly() { console.log("Flying") },
  altitude: 100,
  swim() { console.log("Swimming") },
  depth: 5,
  quack() { console.log("Quack!") }
}

// 第一次声明
interface Window {
  title: string
}

// 第二次声明
interface Window {
  width: number
  height: number
}

// 自动合并为：
// interface Window {
//   title: string
//   width: number
//   height: number
// }

let window: Window = {
  title: "My Window",
  width: 800,
  height: 600
}

// 这个特性常用于扩展第三方库的类型
declare global {
  interface Window {
    myCustomProperty: string
  }
}

// 来自 packages/opencode/src/session/message-v2.ts
export namespace MessageV2 {
  // 基础消息接口
  export interface Info {
    id: string
    sessionID: string
    role: "user" | "assistant" | "system"
    time: {
      created: number
      updated: number
    }
  }

  // 用户消息接口继承基础接口
  export interface User extends Info {
    role: "user"
    variant?: string
    system?: string
    tools?: Record<string, boolean>
  }

  // 助手消息接口继承基础接口
  export interface Assistant extends Info {
    role: "assistant"
    agent: string
    modelID: string
    providerID: string
    finish?: string
  }

  // 带parts的消息接口
  export interface WithParts {
    parts: Part[]
  }
}

// ============ Interface的优势 ============

// 1. 声明合并（只有interface支持）
interface User {
  name: string
}

interface User {
  age: number
}
// 自动合并

// 2. 继承语法更清晰
interface Animal {
  name: string
}

interface Dog extends Animal {
  breed: string
}

// 3. 性能：interface在大型项目中编译更快

// ============ Type的优势 ============

// 1. 联合类型（interface不支持）
type Status = "pending" | "completed" | "failed"
type ID = string | number

// 2. 交叉类型
type Admin = User & { permissions: string[] }

// 3. 映射类型
type Readonly<T> = {
  readonly [P in keyof T]: T[P]
}

// 4. 条件类型
type NonNullable<T> = T extends null | undefined ? never : T

// 5. 元组类型
type Point = [number, number]

// 6. 原始类型别名
type Name = string

// OpenCode混合使用两者

// 使用interface定义对象结构
export interface SessionInfo {
  id: string
  title: string
}

// 使用type定义联合类型和类型别名
export type SessionID = string
export type Status = "idle" | "busy"
export type Part = TextPart | ToolPart | FilePart

// 函数声明
function add(a: number, b: number): number {
  return a + b
}

// 函数表达式
const multiply = (a: number, b: number): number => {
  return a * b
}

// 简写形式
const subtract = (a: number, b: number): number => a - b

// 完整的函数类型注解
const divide: (a: number, b: number) => number = (a, b) => {
  return a / b
}

// 可选参数（使用?）
function buildName(firstName: string, lastName?: string): string {
  if (lastName) {
    return `${firstName} ${lastName}`
  }
  return firstName
}

buildName("Alice")           // 正确
buildName("Alice", "Smith")  // 正确

// 默认参数
function greet(name: string, greeting: string = "Hello"): string {
  return `${greeting}, ${name}!`
}

greet("Alice")              // "Hello, Alice!"
greet("Alice", "Hi")        // "Hi, Alice!"

// 注意：可选参数必须在必需参数之后
// function invalid(a?: string, b: string) {}  // 错误！

// 但默认参数可以在任何位置
function valid(a: string = "default", b: string) {
  return `${a} ${b}`
}

// 剩余参数收集所有额外参数到数组中
function sum(...numbers: number[]): number {
  return numbers.reduce((total, n) => total + n, 0)
}

sum(1, 2, 3)        // 6
sum(1, 2, 3, 4, 5)  // 15

// 剩余参数必须是最后一个参数
function buildArray<T>(first: T, ...rest: T[]): T[] {
  return [first, ...rest]
}

buildArray(1, 2, 3, 4)  // [1, 2, 3, 4]

// 剩余参数的类型可以是元组
function logInfo(message: string, ...details: [number, boolean]): void {
  console.log(message, details[0], details[1])
}

logInfo("Status", 200, true)

// 重载签名（Overload Signatures）
function process(input: string): string
function process(input: number): number
function process(input: string[]): string[]

// 实现签名（Implementation Signature）
function process(input: string | number | string[]): string | number | string[] {
  if (typeof input === "string") {
    return input.toUpperCase()
  } else if (typeof input === "number") {
    return input * 2
  } else {
    return input.map(s => s.toUpperCase())
  }
}

// 调用时TypeScript知道返回类型
let str: string = process("hello")      // string
let num: number = process(42)           // number
let arr: string[] = process(["a", "b"]) // string[]

// 来自 packages/opencode/src/session/index.ts
export namespace Session {
  // 函数重载：根据参数返回不同类型
  export function get(id: string): Promise<Info>
  export function get(id: string, throwIfNotFound: false): Promise<Info | undefined>
  export function get(id: string, throwIfNotFound?: boolean): Promise<Info | undefined> {
    // 实现...
  }
}

interface Database {
  query(sql: string): void
}

// 声明this的类型
function executeQuery(this: Database, sql: string) {
  this.query(sql)  // TypeScript知道this是Database类型
}

const db: Database = {
  query(sql: string) {
    console.log(`Executing: ${sql}`)
  }
}

// 使用call/apply/bind调用
executeQuery.call(db, "SELECT * FROM users")

// 箭头函数不能声明this类型
// const invalid = (this: Database) => {}  // 错误！

// void：函数没有返回值
function log(message: string): void {
  console.log(message)
  // 可以有空return或return undefined
}

// void类型的函数可以返回undefined
function doSomething(): void {
  return undefined  // 正确
}

// never：函数永远不会返回
function throwError(message: string): never {
  throw new Error(message)
  // 永远不会到达这里
}

function infiniteLoop(): never {
  while (true) {
    // 无限循环
  }
}

// never用于穷尽检查
type Shape = Circle | Square

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2
    case "square":
      return shape.size ** 2
    default:
      // 如果所有case都覆盖了，这里的shape类型是never
      const _exhaustive: never = shape
      throw new Error("Unknown shape")
  }
}

// 来自 packages/opencode/src/util/log.ts
export namespace Log {
  export function info(message: string, data?: any): void {
    console.log(message, data)
  }

  export function error(message: string, error?: Error): void {
    console.error(message, error)
  }
}

// 来自 packages/opencode/src/session/prompt.ts
export namespace SessionPrompt {
  export function cancel(sessionID: string): void {
    const match = state()[sessionID]
    if (match) {
      match.abort.abort()
      delete state()[sessionID]
    }
  }
}

// 不使用泛型的问题
function identityNumber(value: number): number {
  return value
}

function identityString(value: string): string {
  return value
}

// 使用any失去类型安全
function identityAny(value: any): any {
  return value
}

// 使用泛型：类型安全且可重用
function identity<T>(value: T): T {
  return value
}

// 使用时可以显式指定类型
let num = identity<number>(42)        // num: number
let str = identity<string>("hello")   // str: string

// 或让TypeScript自动推断
let num2 = identity(42)      // TypeScript推断T为number
let str2 = identity("hello") // TypeScript推断T为string

// 多个类型参数
function pair<T, U>(first: T, second: U): [T, U] {
  return [first, second]
}

let p1 = pair<string, number>("age", 30)  // [string, number]
let p2 = pair("name", true)               // 推断为[string, boolean]

// 实际应用：键值对
function createMap<K, V>(key: K, value: V): Map<K, V> {
  const map = new Map<K, V>()
  map.set(key, value)
  return map
}

let stringToNumber = createMap("count", 42)
let numberToString = createMap(1, "one")

// 泛型数组函数
function first<T>(arr: T[]): T | undefined {
  return arr[0]
}

function last<T>(arr: T[]): T | undefined {
  return arr[arr.length - 1]
}

// 使用
let firstNum = first([1, 2, 3])      // number | undefined
let firstStr = first(["a", "b"])     // string | undefined

// 数组操作
function map<T, U>(arr: T[], fn: (item: T) => U): U[] {
  return arr.map(fn)
}

let numbers = [1, 2, 3]
let strings = map(numbers, n => n.toString())  // string[]

// 过滤
function filter<T>(arr: T[], predicate: (item: T) => boolean): T[] {
  return arr.filter(predicate)
}

let evens = filter([1, 2, 3, 4], n => n % 2 === 0)  // number[]

// 来自 packages/opencode/src/session/message-v2.ts
export namespace MessageV2 {
  // 泛型函数：过滤特定类型的part
  export function filterParts<T extends Part["type"]>(
    parts: Part[],
    type: T
  ): Extract<Part, { type: T }>[] {
    return parts.filter(p => p.type === type) as any
  }

  // 使用
  const textParts = filterParts(message.parts, "text")     // TextPart[]
  const toolParts = filterParts(message.parts, "tool")     // ToolPart[]
}

// 约束类型参数必须有length属性
interface HasLength {
  length: number
}

function logLength<T extends HasLength>(item: T): void {
  console.log(item.length)
}

logLength("hello")           // 正确：string有length
logLength([1, 2, 3])         // 正确：array有length
logLength({ length: 10 })    // 正确：对象有length
// logLength(42)             // 错误：number没有length

// 约束为特定类型
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key]
}

let person = { name: "Alice", age: 30 }
let name = getProperty(person, "name")  // string
let age = getProperty(person, "age")    // number
// getProperty(person, "invalid")       // 错误：不是person的键

// 使用交叉类型实现多重约束
interface Nameable {
  name: string
}

interface Ageable {
  age: number
}

function printInfo<T extends Nameable & Ageable>(obj: T): void {
  console.log(`${obj.name} is ${obj.age} years old`)
}

printInfo({ name: "Alice", age: 30 })  // 正确
// printInfo({ name: "Bob" })          // 错误：缺少age

// 一个类型参数约束另一个类型参数
function copyFields<T extends U, U>(target: T, source: U): T {
  for (let key in source) {
    ;(target as any)[key] = source[key]
  }
  return target
}

// T必须是U的子类型
let x = { a: 1, b: 2, c: 3 }
let y = { a: 10, b: 20 }
copyFields(x, y)  // 正确：x有y的所有属性

// 来自 packages/opencode/src/tool/tool.ts
export namespace Tool {
  export interface Info {
    name: string
    parameters: any
    execute: (input: any) => any
  }

  // 泛型约束：T必须是Tool.Info的子类型
  export type InferParameters<T extends Info> =
    T extends { parameters: infer P } ? P : never

  export type InferResult<T extends Info> =
    T extends { execute: (...args: any[]) => infer R } ? R : never
}

// 使用
type BashParams = Tool.InferParameters<typeof BashTool>
type BashResult = Tool.InferResult<typeof BashTool>

// 基本泛型接口
interface Box<T> {
  value: T
}

let stringBox: Box<string> = { value: "hello" }
let numberBox: Box<number> = { value: 42 }

// 泛型函数接口
interface Transformer<T, U> {
  (input: T): U
}

let toString: Transformer<number, string> = (n) => n.toString()
let toNumber: Transformer<string, number> = (s) => parseInt(s)

// 复杂的泛型接口
interface Repository<T> {
  items: T[]
  add(item: T): void
  remove(id: string): void
  find(predicate: (item: T) => boolean): T | undefined
}

class UserRepository implements Repository<User> {
  items: User[] = []

  add(user: User): void {
    this.items.push(user)
  }

  remove(id: string): void {
    this.items = this.items.filter(u => u.id !== id)
  }

  find(predicate: (user: User) => boolean): User | undefined {
    return this.items.find(predicate)
  }
}

// 基本泛型类型别名
type Container<T> = {
  value: T
  getValue(): T
  setValue(value: T): void
}

// 泛型联合类型
type Result<T, E = Error> =
  | { success: true; data: T }
  | { success: false; error: E }

function divide(a: number, b: number): Result<number> {
  if (b === 0) {
    return { success: false, error: new Error("Division by zero") }
  }
  return { success: true, data: a / b }
}

// 使用Result
let result = divide(10, 2)
if (result.success) {
  console.log(result.data)  // TypeScript知道这里有data
} else {
  console.log(result.error) // TypeScript知道这里有error
}

// 泛型Promise类型
type AsyncResult<T> = Promise<Result<T>>

async function fetchUser(id: string): AsyncResult<User> {
  try {
    const user = await api.getUser(id)
    return { success: true, data: user }
  } catch (error) {
    return { success: false, error: error as Error }
  }
}

// 基本泛型类
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
  }
}

let numberStack = new Stack<number>()
numberStack.push(1)
numberStack.push(2)
let top = numberStack.pop()  // number | undefined

// 泛型类继承
class NamedStack<T> extends Stack<T> {
  constructor(public name: string) {
    super()
  }
}

let myStack = new NamedStack<string>("MyStack")

// 来自 packages/opencode/src/storage/storage.ts
export namespace Storage {
  // 泛型存储接口
  export interface Store<T> {
    get(key: string): Promise<T | undefined>
    set(key: string, value: T): Promise<void>
    delete(key: string): Promise<void>
    list(): Promise<T[]>
  }

  // 实现泛型存储
  export class FileStore<T> implements Store<T> {
    constructor(private directory: string) {}

    async get(key: string): Promise<T | undefined> {
      // 实现...
    }

    async set(key: string, value: T): Promise<void> {
      // 实现...
    }

    async delete(key: string): Promise<void> {
      // 实现...
    }

    async list(): Promise<T[]> {
      // 实现...
    }
  }
}

// 基本默认类型参数
interface Container<T = string> {
  value: T
}

let container1: Container = { value: "hello" }  // T默认为string
let container2: Container<number> = { value: 42 }

// 多个默认类型参数
type Result<T = any, E = Error> =
  | { success: true; data: T }
  | { success: false; error: E }

let result1: Result = { success: true, data: "anything" }
let result2: Result<number> = { success: true, data: 42 }
let result3: Result<number, string> = {
  success: false,
  error: "Custom error"
}

// 默认类型参数的约束
interface Response<T = unknown, E extends Error = Error> {
  data?: T
  error?: E
}

// 深度克隆
function deepClone<T>(obj: T): T {
  return JSON.parse(JSON.stringify(obj))
}

// 合并对象
function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 }
}

// 选择属性
function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
  const result = {} as Pick<T, K>
  for (const key of keys) {
    result[key] = obj[key]
  }
  return result
}

// 使用
let person = { name: "Alice", age: 30, email: "alice@example.com" }
let nameAndAge = pick(person, ["name", "age"])  // { name: string; age: number }

// 省略属性
function omit<T, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {
  const result = { ...obj }
  for (const key of keys) {
    delete result[key]
  }
  return result
}

let withoutEmail = omit(person, ["email"])  // { name: string; age: number }

// 来自 packages/opencode/src/util/fn.ts
export function fn<I, O>(
  schema: z.ZodType<I>,
  handler: (input: I) => O
): (input: unknown) => O {
  return (input: unknown) => {
    const validated = schema.parse(input)
    return handler(validated)
  }
}

// 使用
const createUser = fn(
  z.object({
    name: z.string(),
    email: z.string().email()
  }),
  (input) => {
    // input的类型自动推断为{ name: string; email: string }
    return { id: generateId(), ...input }
  }
)

// 基本联合类型
type StringOrNumber = string | number

let value: StringOrNumber = "hello"
value = 42  // 正确

// 字面量联合类型
type Status = "pending" | "running" | "completed" | "failed"
type HttpMethod = "GET" | "POST" | "PUT" | "DELETE"

let status: Status = "pending"
// status = "unknown"  // 错误！

// 对象联合类型
type Success = { success: true; data: string }
type Failure = { success: false; error: Error }
type Result = Success | Failure

function handleResult(result: Result) {
  if (result.success) {
    console.log(result.data)  // TypeScript知道这里有data
  } else {
    console.log(result.error) // TypeScript知道这里有error
  }
}

// 可辨识联合的标准模式
interface Circle {
  kind: "circle"  // 判别式
  radius: number
}

interface Square {
  kind: "square"  // 判别式
  size: number
}

interface Triangle {
  kind: "triangle"  // 判别式
  base: number
  height: number
}

type Shape = Circle | Square | Triangle

// TypeScript可以根据kind自动收窄类型
function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2  // shape是Circle
    case "square":
      return shape.size ** 2  // shape是Square
    case "triangle":
      return (shape.base * shape.height) / 2  // shape是Triangle
    default:
      // 穷尽检查：如果所有case都覆盖了，这里的shape是never
      const _exhaustive: never = shape
      throw new Error("Unknown shape")
  }
}

// 来自 packages/opencode/src/session/message-v2.ts
export namespace MessageV2 {
  // 可辨识联合：使用type作为判别式
  export type Part =
    | { type: "text"; text: string; time?: TimeInfo }
    | { type: "tool"; tool: string; state: ToolState }
    | { type: "file"; url: string; filename: string }
    | { type: "reasoning"; text: string; time?: TimeInfo }
    | { type: "compaction"; summary: string }

  // 根据type自动收窄类型
  function processPart(part: Part) {
    switch (part.type) {
      case "text":
        console.log(part.text)  // TypeScript知道有text属性
        break
      case "tool":
        console.log(part.tool, part.state)  // TypeScript知道有tool和state
        break
      case "file":
        console.log(part.url, part.filename)  // TypeScript知道有url和filename
        break
    }
  }
}

// 基本交叉类型
interface Timestamped {
  timestamp: number
}

interface Tagged {
  tags: string[]
}

type TimestampedAndTagged = Timestamped & Tagged

let item: TimestampedAndTagged = {
  timestamp: Date.now(),
  tags: ["important", "urgent"]
}

// 扩展类型
interface User {
  id: string
  name: string
}

type Admin = User & {
  permissions: string[]
  role: "admin"
}

let admin: Admin = {
  id: "123",
  name: "Alice",
  permissions: ["read", "write", "delete"],
  role: "admin"
}

// 混合（Mixin）模式
function extend<T, U>(first: T, second: U): T & U {
  return { ...first, ...second }
}

let person = { name: "Bob" }
let employee = { employeeId: "E123" }
let personEmployee = extend(person, employee)
// personEmployee: { name: string } & { employeeId: string }

// 来自 packages/opencode/src/session/message-v2.ts
export namespace MessageV2 {
  // 基础接口
  export interface Info {
    id: string
    sessionID: string
    role: string
  }

  // 使用交叉类型扩展
  export type User = Info & {
    role: "user"
    variant?: string
    tools?: Record<string, boolean>
  }

  export type Assistant = Info & {
    role: "assistant"
    agent: string
    modelID: string
  }
}

function padLeft(value: string, padding: string | number) {
  if (typeof padding === "number") {
    // 这里padding是number
    return " ".repeat(padding) + value
  }
  // 这里padding是string
  return padding + value
}

// typeof可以检查的类型
function checkType(value: unknown) {
  if (typeof value === "string") {
    console.log(value.toUpperCase())
  } else if (typeof value === "number") {
    console.log(value.toFixed(2))
  } else if (typeof value === "boolean") {
    console.log(value ? "yes" : "no")
  } else if (typeof value === "function") {
    value()
  } else if (typeof value === "object") {
    // 注意：null的typeof也是"object"
    if (value === null) {
      console.log("null")
    } else {
      console.log("object")
    }
  }
}

class Bird {
  fly() {
    console.log("Flying")
  }
  layEggs() {
    console.log("Laying eggs")
  }
}

class Fish {
  swim() {
    console.log("Swimming")
  }
  layEggs() {
    console.log("Laying eggs")
  }
}

function move(animal: Bird | Fish) {
  if (animal instanceof Bird) {
    animal.fly()  // TypeScript知道这是Bird
  } else {
    animal.swim()  // TypeScript知道这是Fish
  }

  // 两者都有的方法可以直接调用
  animal.layEggs()
}

// instanceof也可以用于内置类型
function processValue(value: Date | string) {
  if (value instanceof Date) {
    console.log(value.toISOString())
  } else {
    console.log(value.toUpperCase())
  }
}

interface Car {
  drive(): void
}

interface Boat {
  sail(): void
}

function operate(vehicle: Car | Boat) {
  if ("drive" in vehicle) {
    vehicle.drive()  // TypeScript知道这是Car
  } else {
    vehicle.sail()  // TypeScript知道这是Boat
  }
}

// in也可以检查可选属性
interface Person {
  name: string
  age?: number
}

function printAge(person: Person) {
  if ("age" in person && person.age !== undefined) {
    console.log(`Age: ${person.age}`)
  }
}