未按预期推断 TypeScript 类型

Question

I have a use case where I want to define a set of filters as an object. I want to know which filters there are exactly and have auto completion for it, but in the generic handling of the filters, it can be just be any key as long as it adheres to certain types for their values. I thought to use generics and extends, which works to a certain degree, but there are a few situations where it does not unify based on the type it is extending like I would expect it too. Here is a simplified example of what I attempted and what goes wrong:

type Foo = { [key: string]: boolean | string[] }
class Bar<F extends Foo> {
  constructor(public arg: F) {}
}
const bar = new Bar({ foo: false, bar: [] })
// Reported as always being false.
console.log(bar.arg.foo)
for (const n of bar.arg.bar) {
  // Property 'includes' does not exist on type 'never'. ts(2339)
  n.includes("x")
}

I expected it to infer boolean rather than false (for foo ), and string[] rather than never[] (for bar ). I assume extends does not unify the types quite as I expected. Is there a way to achieve this in TypeScript? Meaning I would get full knowledge that the instance of Bar has the properties foo and bar , but inside the class itself, it only knows the generic type (as in, some object, rather than knowing its specific keys).

Answer 1

The answer given by @jcalz in the comments to my question was the answer I was looking for. I ended up implementing it similarly to the example given by him:

type Foo = { [key: string]: boolean | string[] }

type WidenFoo<T extends Foo> = { [K in keyof T]: T[K] extends boolean ? boolean : string[] };

class Bar<F extends Foo> {
    arg: WidenFoo<F>
    constructor(arg: F) {
        this.arg = arg as WidenFoo<F>;
    }
}
const bar = new Bar({ foo: false, bar: [] })

bar.arg.foo // boolean
bar.arg.bar // string[]

console.log(bar.arg.foo)
for (const n of bar.arg.bar) {    
    n.includes("x")
} 

As he mentioned, per PR ms/TS#10676 , literal types will be used whenever applicable and will be as specific (narrow) as possible. AFAIK there is no way to have TypeScript widen literal types automatically, so we have to do it ourselves via T extends Type ? Type : ... T extends Type ? Type : ... tricks. I tried it and it works well for more complex types too, such as my use case (has recursive types and such).