TypeScript 是否允许从键数组到 map 键入到带有键的 object？

Question

I'm trying to add types for a library with an interesting API. To simplify the problem, it's a function that takes this:

const payload = {
  returns: {
    users: ['user1', 'user2'],
    posts: ['post1', 'post2'],
  }
}

And turns it into an object with this shape:

{
  users: {
    user1: any
    user2: any
  }
  posts: {
    post1: any
    post2: any
  }
}

The main problem I'm seeing is that TypeScript infers those arrays as string[] rather than as constants. I would normally do as const , but I'm writing these typings to add types to a JS library—so users of the library, who are writing JavaScript, can't use as const .

Edit: To clarify some more, the reason I'm doing this is because adding types to JavaScript packages is still helpful even to JS users, because Intellisense is powered by TypeScript, and a large portion of the company uses VS Code.

Answer 1

The TS type checker uses certain heuristics to infer types for values. Generally speaking a variable initialized with array literal of strings like const arr = ["foo", "bar"] will be inferred to be of type Array<string> , because oftentimes developers will go on to modify the contents of arrays. If it were to infer the type of arr as, say, Array<"foo" | "bar"> Array<"foo" | "bar"> , developers would find themselves unable to put any strings other than "foo" or "bar" into the array... which would be pretty annoying.

There are times, however, where the type checker can be persuaded to infer things more narrowly. The shortest and least "wacky" way of doing this is probably to use a const assertion via as const . The problem here is that it requires the person creating the value to do the assertion. In your case this would be users of the library, and you don't want to burden them with that. It's even worse for you because they are writing JavaScript, and there isn't currently a JSDoc version of as const . See microsoft/TypeScript#30445 for an open feature request to support this.

You'd prefer your library function call signature to be able to ask for a narrower type. Essentially to behave as if the caller had put as const in there. Sadly there is no analogously simple way of writing such a call signature. See microsoft/TypeScript#30680 for an open feature request (filed by me fwiw) to allow something like this.

For now, we have to use the "wacky" ways of doing this. If you want the type checker to see a string like "foo" and not widen it to string , one way to do it is to have it match up with a generic type parameter like K extends string instead of just string . Even though the compiler might not infer K to be anything useful, it will allow things that depend on K to stay narrow. It's wacky, I know. I go into this in microsoft/TypeScript#30680.

Here's one possible signature:

declare function transform<
    T extends Record<keyof T, readonly K[]>,
    K extends string
>(obj: { returns: T }): { [K in keyof T]: { [P in T[K][number]]: any } };

It takes a param of type {returns: T} , where T is some object whose properties are K arrays, where K extends string . Again, we're just doing that instead of string[] to cause the type checker to keep track of string literals passed to it:

const transformed = transform({
    returns: {
        users: ['user1', 'user2'],
        posts: ['post1', 'post2'],
    }
})
/* const transformed: {
    users: {
        user1: any;
        user2: any;
    };
    posts: {
        post1: any;
        post2: any;
    };
} */

Hooray!

---

Of course this will fail if the caller assigns the payload to a new variable before passing it into transform() . Any hints or other demands that the type checker infer string literals from the function input will be useless if the function input's type has already been widened to something where it has forgotten the string literals. At that point you need to ask users to use as const or something similar (for JS users you can make an identity asConstish() function that looks like the foo() function from microsoft/TypeScript#30680). Or just tell users not to save it to a variable first.

Playground link to code