从 function 中返回 object，其中键基于 Z9327DAFFB330417F817934CC29 中的输入 object 的属性

Question

I'm trying to create a function that receives an object with certain properties, then use one of those properties in order to generate the types of the result.

function params

interface Params<T> {
  entries?: { [key in T['entries']: string]: number }
  unit?: string
}

and the result

type Result<T> = { [key in T: string]: string }

where T in the result is Params['entries']

I setup a simple typescript playground to display my attempt.

At the moment, if you type result. it only suggests big|small which are the default values, and not a which was the actual object input.

Answer 1

The problem lies here

generateUnitStrings = <O>(options?: Params<O>) // ---> the <O>

What is O? That's why PickEntries<O> extends never returns true. One way to check is doing this

const result = generateUnitStrings<{ entries: { a: number } }>({ entries: { a: 1 } })

And you'll see that it actually works. autocompletion correctly suggests 'a'. The reason is when you call generateUnitStrings , O correctly gets switched with { entries: { a: number } } and passes it to Params and everything works.

Try this (it looks a little bit weird to me, but it actually works:):

export const generateUnitStrings = <O extends Params<O>>(options?: O) => {
...

---

EDIT

Yes, but now your solution only suggests something if generateUnitStrings() has parameters, if it used empty as generateUnitStrings() it doesn't auto-suggests the default parameters small|big

Providing a default generic type (in this case typeof defaultParams) seems to get the job done

export const generateUnitStrings = <O extends Params<O> = typeof defaultParams>(options?: O) => {
  const entries = (options && options.entries) || defaultParams.entries
  const unit = (options && options.unit) || defaultParams.unit

  return Object.keys(entries).reduce(
    (acc, v) => ({ ...acc, [v]: `${entries[v as keyof typeof entries]}${unit}` }),
    {}
  ) as PickEntries<O> extends never ? Result<PickEntries<typeof defaultParams>> : Result<PickEntries<O>>
}

Playground

Your initial code for reference

type FilterProperties<T, P> = {
  [K in keyof T]: K extends P ? K : never
}[keyof T]
type PickEntries<T> = T[FilterProperties<T, 'entries'>]

interface Params<T> {
  entries?: { [K in keyof PickEntries<T>]: number }
  unit?: string
}

type Result<T> = { [P in keyof T]: string }

export const defaultParams = {
  entries: {
    small: 600,
    big: 1200,
  },
  unit: 'px',
}

export const generateUnitStrings = <O>(options?: Params<O>) => {
  const entries = (options && options.entries) || defaultParams.entries
  const unit = (options && options.unit) || defaultParams.unit

  return Object.keys(entries).reduce(
    (acc, v) => ({ ...acc, [v]: `${entries[v as keyof typeof entries]}${unit}` }),
    {}
  ) as PickEntries<O> extends never ? Result<PickEntries<typeof defaultParams>> : Result<PickEntries<O>>
}

const result = generateUnitStrings({ entries: { a: 1 } })