function FiberNode(
  this: $FlowFixMe,
  tag: WorkTag,
  pendingProps: mixed,
  key: null | string,
  mode: TypeOfMode
) {
  // Instance 作为静态数据结构的属性
  this.tag = tag
  this.key = key
  this.elementType = null
  this.type = null
  this.stateNode = null

  // Fiber 用于连接其他 FiberNode 形成 Fiber Tree
  this.return = null
  this.child = null
  this.sibling = null
  this.index = 0

  this.ref = null
  this.refCleanup = null

  // 作为动态的工作单元的属性
  this.pendingProps = pendingProps
  this.memoizedProps = null
  this.updateQueue = null
  this.memoizedState = null
  this.dependencies = null

  this.mode = mode

  // Effects
  this.flags = NoFlags
  this.subtreeFlags = NoFlags
  this.deletions = null

  // 调度优先级相关
  this.lanes = NoLanes
  this.childLanes = NoLanes

  // 指向该fiber在另一次更新时对应的fiber
  this.alternate = null
}

class Singleton {
  // 保存单例实例的私有静态属性
  private static instance: Singleton
  // 构造函数私有化，防止外部实例化
  private constructor() {
    // 初始化代码
  }
  // 获取单例实例的静态方法
  public static getInstance(): Singleton {
    // 如果实例不存在，创建一个新的实例
    if (!Singleton.instance) {
      Singleton.instance = new Singleton()
    }
    // 返回唯一的实例
    return Singleton.instance
  }
  // 示例方法
  public someMethod() {
    console.log('This is a method of the Singleton class.')
  }
}
// 使用单例
const singleton1 = Singleton.getInstance()
const singleton2 = Singleton.getInstance()

// 验证两个实例是否相同
console.log(singleton1 === singleton2) // true

// 调用示例方法
singleton1.someMethod()

interface Product {
    operation(): string
}
class ConcreteProductA implements Product {
    public operation():string {
        return 'Result of the ConcreteProductA'
    }
}
class ConcreteProductB implements Product {
    public operation():string {
        return 'Result of the ConcreteProductB'
    }
}

class ProductFactory {
    public static createProduct(type:string):Product {
        switch(type) {
        	case: 'A':
                return new ConcreteProductA()
            case: 'B':
                return new ConcreteProductB();
            default:
                throw new Error('Unknow product type.')
        }
    }
}

// 创建产品A的实例
const productA: Product = ProductFactory.createProduct('A');
console.log(productA.operation()); // 输出: Result of the ConcreteProductA

// 创建产品B的实例
const productB: Product = ProductFactory.createProduct('B');
console.log(productB.operation()); // 输出: Result of the ConcreteProductB

// 观察目标
class SubJect {
  constructor() {
    this.observes = []
  }
  add(observe) {
    this.observes.push(observe)
  }
  remove(observe) {
    this.observes = this.observes.filter((item) => item !== observe)
  }
  notify() {
    this.observes.forEach((item) => {
      item.update()
    })
  }
}

// 观察者
class Observe {
  constructor(name) {
    this.name = name
  }
  update() {
    console.log('update', this.name)
  }
}

const observe1 = new Observe('observe1')
const observe2 = new Observe('observe2')
const sub = new SubJect()
sub.add(observe1)
sub.add(observe2)
sub.remove(observe1)
sub.notify()

Function.prototype.before = function (beforeFn) {
  const that = this
  return function (...args) {
    beforeFn.apply(this, ...args)
    return that.apply(this, ...args)
  }
}

const log = () => {
  console.log('打印上传前的日志')
}

const upload = () => {
  console.log('上传数据')
}

newUpload = upload.before(log)
newUpload()

import 'reflect-metadata'

// 定义装饰器
function Get(path: string): MethodDecorator {
  return (target, propertyKey) => {
    Reflect.defineMetadata('path', path, target, propertyKey)
  }
}

// 使用 fetch 发起请求
async function fetchRequest(path: string) {
  const response = await fetch(path)
  const data = await response.json()
  return data
}

// 装饰器处理器
function handleRequest(
  target: any,
  propertyKey: string,
  descriptor: PropertyDescriptor
) {
  const method = descriptor.value

  descriptor.value = async function (...args: any[]) {
    const path = Reflect.getMetadata('path', target, propertyKey)
    if (path) {
      const data = await fetchRequest(path)
      return method.apply(this, [data, ...args])
    }
    return method.apply(this, args)
  }
}

// 示例控制器
class MyController {
  @Get('https://jsonplaceholder.typicode.com/todos/1')
  @handleRequest
  async fetchData(data: any) {
    console.log('Fetched Data:', data)
  }
}

// 使用控制器
;(async () => {
  const controller = new MyController()
  await controller.fetchData()
})()

// 策略接口
interface PaymentStrategy {
  pay(amount: number): void
}

// 具体策略：信用卡支付
class CreditCardPayment implements PaymentStrategy {
  pay(amount: number): void {
    console.log(`Paid ${amount} using Credit Card.`)
  }
}

// 具体策略：PayPal支付
class PaypalPayment implements PaymentStrategy {
  pay(amount: number): void {
    console.log(`Paid ${amount} using PayPal.`)
  }
}

// 上下文类
class PaymentContext {
  private strategy: PaymentStrategy

  constructor(strategy: PaymentStrategy) {
    this.strategy = strategy
  }

  setStrategy(strategy: PaymentStrategy) {
    this.strategy = strategy
  }

  executeStrategy(amount: number): void {
    this.strategy.pay(amount)
  }
}

const creditCardPayment = new CreditCardPayment()
const paypalPayment = new PaypalPayment()

const paymentContext = new PaymentContext(creditCardPayment)
paymentContext.executeStrategy(100)

paymentContext.setStrategy(paypalPayment)
paymentContext.executeStrategy(200)

class TencentMap {
  show() {
    console.log('腾讯地图渲染')
  }
}

class BaiduMap {
  display() {
    console.log('百度地图渲染')
  }
}

class TencentMapAdapter extends TencentMap {
  constructor() {
    super()
  }
  showMap() {
    this.show()
  }
}

class BaiduMapAdapter extends BaiduMap {
  constructor() {
    super()
  }
  showMap() {
    this.display()
  }
}

function render(map) {
  map.showMap()
}

render(new TencentMapAdapter())
render(new BaiduMapAdapter())