如何修改常量对象类型的值类型#类型记录

Question

我有一个常量对象类型，其值类型是一个函数。我希望通过这种类型获得另一个常量对象类型，并将函数的返回值类型更改为允诺类型。

const CONST_METHOD_MAP = {
  ready: (str: string) => str,
  b: (num: number) => num,
  c: () => Promise.resolve(1)
} as const

想要

type CONST_METHOD_MAP: {
    readonly ready: (str: string) => Promise<string>;
    readonly b: (num: number) => Promise<number>;
    readonly c: () => Promise<number>;
}

type MyType<K extends keyof CONST_METHOD_MAP = keyof typeof CONST_METHOD_MAP> =
  {
    [k in K]: (
      ...args: Parameters<CONST_METHOD_MAP[K]>
    ) => Promise<ReturnType<CONST_METHOD_MAP[K]>>
  }

// an array containing workers created according to navigator.hardwareConcurrency
const workerStore = [
  {
    worker: new Worker(new URL('./worker0.ts', import.meta.url), {
      type: 'module'
    }),
    syncTaskCount: 0
  },
  {
    worker: new Worker(new URL('./worker1.ts', import.meta.url), {
      type: 'module'
    }),
    syncTaskCount: 1
  },
  // ...more worker
]
// I will follow CONST_ METHOD_ MAP constructs a set of functions that call web worker execution logic
const funcMap = {
  ready: (...args: Parameters<typeof CONST_METHOD_MAP['ready']>) => {
    const promise = new Promise<ReturnType<typeof CONST_METHOD_MAP['ready']>>(
      resolove => {
        const worker = takeWorker().worker // take a worker who is not executing synchronization function
        const hander = (
          e: MessageEvent<{
            key: 'ready'
            res: ReturnType<typeof CONST_METHOD_MAP['ready']>
            traceId: number
            type: 'resolve' | 'setup'
          }>
        ) => {
          if (e.data.traceId !== traceId) {
            return
          } else if (e.data.type === 'resolve') {
            resolove(e.data.res)
            worker.removeEventListener('message', hander)
          } else if (e.data.type === 'setup') {
            workerStore.find(item => item.worker === worker)?.syncTaskCount--
          }
        }
        worker.addEventListener('message', hander)
        worker.postMessage({ key: 'ready', args: args, traceId: 123456789 })
      }
    )
    return promise
  },
  b: (
    ...args: Parameters<typeof CONST_METHOD_MAP['b']>
  ): Promise<ReturnType<typeof CONST_METHOD_MAP['b']>> => {
    // ...
  },
  c: (
    ...args: Parameters<typeof CONST_METHOD_MAP['c']>
  ): Promise<ReturnType<typeof CONST_METHOD_MAP['c']>> => {
    // ...
  }
} as MyType
const res = funcMap.ready()
/**
The res type derived by typescript is const res: Promise<string | number | Promise<number>>

The res type I expect is Promise<string>
*/

原因是我希望将某些函数转换为worker函数，因此CONST_ METHOD_映射是我配置并希望转换为worker的同步函数的集合。因此，我的funcMap值的内容是调用worker的函数，因此它的返回值将从同步变为异步。因为我的funcMap是从常量对象生成的，所以它的类型也应该是常量类型。

我想要构建一个常量对象类型。当我调用我的funcMap Ready()时，我希望funcMap参数类型是Parameters，而不是CONST_METHOD_MAP>类型的Parameters，而不是Promise>类型.

Answer 1

CONST_METHOD_MAP是一个常量，而不是一个类型，如果没有typeof，使用它作为一个类型是行不通的。

所以，您需要做的是在使用typeof时使用CONST_METHOD_MAP，同时也要使用K (大写)，这就是为什么您的类型不正确，使用小写k，并且它将工作。

const CONST_METHOD_MAP = {
  ready: (str: string) => str,
  b: (num: number) => num,
  c: () => Promise.resolve(1)
} as const

type MyType<K extends keyof typeof CONST_METHOD_MAP = keyof typeof CONST_METHOD_MAP> =
  {
    [k in K]: (
      ...args: Parameters<typeof CONST_METHOD_MAP[k]> // You were using uppercase K here
    ) => Promise<ReturnType<typeof CONST_METHOD_MAP[k]>> // and here
  }

const funcMap = {} as MyType
const res = funcMap.ready()