interface Enum {
  [id: number]: string
}

const getEnumKeys = (e: Enum) => {
  return Object.keys(e)
    .map(key => e[key])
    .filter(value => typeof value === 'string') as string[]
}

enum TrafficLight {
  red = 1,
  green = 2,
  yellow = 3,
}

namespace TrafficLight {
  export function keys() {
    return getEnumKeys(TrafficLight)
  }

  export function parse(light: Number): TrafficLight {
    return <TrafficLight>light
  }

  export function desc(light: TrafficLight) {
    switch (light) {
      case TrafficLight.green:
        return '绿灯'
      case TrafficLight.red:
        return '红灯'
      case TrafficLight.yellow:
        return '黄灯'

      default:
        return ''
      // 或者 throw new Error("参数错误")
    }
  }
}

console.error('emmmmmm')
console.log(TrafficLight.keys())
console.log(TrafficLight.desc(2))

interface EnumDataType<ValueType> {
  [k: string]: {
    value: ValueType
    label: string
  }
}

// String
export class EnumString<T extends Readonly<EnumDataType<string>>> {
  data!: T
  constructor(x: T) {
    this.data = x

    const byValue: any = {}
    const byLabel: any = {}

    Object.keys(x).forEach(key => {
      byValue[key] = x[key].value
      byLabel[key] = x[key].label
    })

    this.value = byValue
    this.label = byLabel
    this.options = Object.entries(x).map(entry => {
      const k = entry[0]
      const v = entry[1]
      const option = { ...v, name: k }
      return option
    })
  }

  value: Readonly<
    {
      [k in keyof T]: T[k]['value']
    }
  >

  label: Readonly<
    {
      [k in keyof T]: T[k]['label']
    }
  >

  options: Readonly<{ label: string; value: string; name: string }[]>

  labelFor(e: string) {
    let findLabel = Object.entries(this.data).find(entry => {
      return entry[1].value === e
    })

    const value = Array.isArray(findLabel) && findLabel.length >= 1 && findLabel[1]
    return value ? value.label : ''
  }

  static init<T extends Readonly<EnumDataType<string>>>(e: T) {
    return new EnumString(e)
  }
}

// Number
export class EnumNumber<T extends Readonly<EnumDataType<number>>> {
  data!: T
  constructor(x: T) {
    this.data = x

    const byValue: any = {}
    const byLabel: any = {}

    Object.keys(x).forEach(key => {
      byValue[key] = x[key].value
      byLabel[key] = x[key].label
    })

    this.value = byValue
    this.label = byLabel
    this.options = Object.entries(x).map(entry => {
      const k = entry[0]
      const v = entry[1]
      const option = { ...v, name: k }
      return option
    })
  }

  value: Readonly<
    {
      [k in keyof T]: T[k]['value']
    }
  >

  label: Readonly<
    {
      [k in keyof T]: T[k]['label']
    }
  >

  options: Readonly<{ label: string; value: number; name: string }[]>

  labelFor(e: number) {
    let findLabel = Object.entries(this.data).find(entry => {
      return entry[1].value === e
    })

    const value = Array.isArray(findLabel) && findLabel.length >= 1 && findLabel[1]
    return value ? value.label : ''
  }

  static init<T extends Readonly<EnumDataType<number>>>(e: T) {
    return new EnumNumber(e)
  }
}

// Demo
// let TrafficLight = EnumNumber.init({
//   red: {
//     label: '红灯',
//     value: 1,
//   },
//   green: {
//     label: '绿灯',
//     value: 1,
//   },
// })

// TrafficLight.options
// TrafficLight.labelFor(1)
// if(TrafficLight.value.red === 服务端.some){

// }

import { useEffect, useState } from 'react'

const cachedScripts: string[] = []

export default function useScript(src: string) {
  // Keeping track of script loaded and error state
  const [state, setState] = useState({
    loaded: false,
    error: false,
  })

  useEffect(
    () => {
      // If cachedScripts array already includes src that means another instance ...
      // ... of this hook already loaded this script, so no need to load again.
      if (cachedScripts.includes(src)) {
        setState({
          loaded: true,
          error: false,
        })
        return () => {}
      } else {
        cachedScripts.push(src)

        // Create script
        const script = document.createElement('script')
        script.src = src
        script.async = true

        // Script event listener callbacks for load and error
        const onScriptLoad = () => {
          setState({
            loaded: true,
            error: false,
          })
        }

        const onScriptError = () => {
          // Remove from cachedScripts we can try loading again
          const index = cachedScripts.indexOf(src)
          if (index >= 0) cachedScripts.splice(index, 1)
          script.remove()

          setState({
            loaded: true,
            error: true,
          })
        }

        script.addEventListener('load', onScriptLoad)
        script.addEventListener('error', onScriptError)

        // Add script to document body
        document.body.appendChild(script)

        // Remove event listeners on cleanup
        return () => {
          script.removeEventListener('load', onScriptLoad)
          script.removeEventListener('error', onScriptError)
        }
      }
    },
    [src], // Only re-run effect if script src changes
  )

  return [state.loaded, state.error]
}

{
  "code": 200,
  "data": {
    "xxxCount": "",
    "xxxCode": 0
  },
  "msg": ""
}

{
  "code": 200,
  "data": "",
  "msg": ""
}