Tukukkk

I am trying to produce an events property on Klass which contains an array of strings that exactly matches all the keys of a given interface. Like so:

interface Events {

    one: (foo: string) => void

    two: (bar: number) => void

}



class Klass {

    protected readonly events: [keyof Events] = ['one', 'two']

}

However, the above errors out with the following:

[ts]

Type '["one", "two"]' is not assignable to type '["one" | "two"]'.

  Types of property 'length' are incompatible.

    Type '2' is not assignable to type '1'. [2322]

(property) Klass.events: ["one" | "two"]

What is needed here to ensure that the events property returns an array that contains all of the events?

I think you need a concrete object to achieve your goal here. In the example below, the implementation of the interface gives you a guaranteed way to get the right list. If you add a new member to Events it will force you to add it to ConcreteEvents. The only potential issue would be if you add other members to ConcreteEvents.

interface Events {

    one: (foo: string) => void;

    two: (bar: number) => void;

}



class ConcreteEvents implements Events {

    // Note! Only add members of Events

    one(foo: string) { };

    two(bar: number) { };

}



class Klass {

    public readonly events = Object.keys(ConcreteEvents.prototype) as any as [keyof Events];

}



const klass = new Klass();

console.log(klass.events);

You could achieve this in several different ways using a concrete class or an object, so you don't have to follow this example exactly.

You can almost express this in the type system (assuming TS3.0+) with conditional types, with a few caveats:

type Invalid<T> = ["Needs to be all of", T]

const arrayOfAll = <T>() => <U extends T>(

  ...array: U & ([T] extends [U[number]] ? unknown : Invalid<T>)

) => array;

const arrayOfAllEventKeys = arrayOfAll<keyof Events>();



const goodEvents = arrayOfAllEventKeys('one', 'two'); // okay, type ['one', 'two']



const extraEvents = arrayOfAllEventKeys('one', 'two', 'three'); // error

//                                                    ~~~~~~~ 

// Argument of type "three" is not assignable to parameter of type "one" | "two"



const missingEvents = arrayOfAllEventKeys('one'); // error

//                                        ~~~~~ 

// Argument of type "one" is not assignable to 

// parameter of type ["Needs to be all of", "one" | "two"]



const redundantEvents = arrayOfAllEventKeys('one', 'two', 'one'); // no error

// doesn't enforce distinctness

Note that goodEvents is inferred to be of type ['one', 'two'], and there is no error. That's what you want. You get errors on extra events and on missing events.

Caveat 1: The error for missing events is a bit cryptic; TypeScript doesn't yet support custom error messages, so I chose something that hopefully is somewhat understandable (Argument of type "one" is not assignable to parameter of type ["Needs to be all of", "one" | "two"]).

Caveat 2: There is no error for redundant events. There's no general way that I can find to require that each parameter to arrayOfAllEventKeys is of a distinct type that doesn't run afoul of some issues with recursive types. It's possible to use overloading or other similar techniques to work for arrays of up to some hardcoded length (say, 10), but I don't know if that would meet your needs. Let me know.

Hope that helps; good luck!