Inconsistent behaviour with Object.values and enums with number values

[BennoDev]

TypeScript Version:

Version used: 3.3.3333

I have reproduced this using typescript/@next which at the time of writing is 3.4.0-dev.20190319

Search Terms:

object.values
object.values enum
enum values

Code

enum DirectionNumber {
    Down,
    Neutral,
    Up
}

console.log(Object.values(DirectionNumber);

// output ["Down", "Neutral", "Up", 0, 1, 2]

Expected behavior:

Expecting consistent output, logging the enum values correctly.

This expected behaviour is also shown in the provided playground where I compare it with the erroneous behaviour.

Actual behavior:

When Object.values gets passed an enum with numbers as values, the resulting array contains both these numbers AND the keys. This seems unintuitive and unintended behaviour.

Playground Link:

Playground link

Related Issues:

[jcready]

This is well documented and intended behavior. See documentation for reverse mappings in enums.

[BennoDev]

Ah alright, thanks, I skimmed over that part of the documentation.

I have no doubt that the generated code is intended, however to me this behaviour conflicts with what is also documented ''enums are real objects that exist at runtime".

Given the fact that enums in typecript have been around longer than Object.values() in ES the statement that 'enums are objects' has always been true, up to this point.

If the intention is for people to be able to use enums as 'just objects' in runtime, then it should function correctly with all methods on the Object constructor.

[nmain]

I don't see a conflict there. In order for DirectionNumber.Down == 0 and DirectionNumber[0] == "Down" to be true, then in the transpiled js DirectionNumber has to have a shape that looks something like:

var DirectionNumber = { Down: 0, 0: "Down" };

But then, without any typescript involvement you get:

console.log(Object.values(DirectionNumber)); // ["Down", 0]

And this is exactly what you'd expect out of any plain javascript object that obeyed obj.Down == 0 && obj[0] == "Down"

[BennoDev]

I understand the logic and reasoning behind the generated code, and why they currently appear in these arrays, but I disagree that this behaviour is desirable.
The fact is that 2 very similar and valid uses of enums behave quite differently.
On top of that it doesn't seem intuitive that a method called Object.values returns an array containing both key and values (and the other way around for Object.keys), for something that is for all intents and purposes designed to behave just like a normal object/key-value pair.

It's possible to skip enumeration of these key/value pairs generated for reverse mapping using Object.defineProperty, and still have properly functional reverse-mapping through property access. Demonstration here

[RyanCavanaugh]

The codegen for enums was chosen when ES3 targets (which don't have defineProperty) were still very common. Generating substantially different code between ES3 and ES5 targets is a worse inconsistency than someone's first-guess interpretation of Object.keys(E) being wrong.